diff --git a/crates/jstz_cli/src/bridge/deposit.rs b/crates/jstz_cli/src/bridge/deposit.rs
index c4c8942e8..1b011f04d 100644
--- a/crates/jstz_cli/src/bridge/deposit.rs
+++ b/crates/jstz_cli/src/bridge/deposit.rs
@@ -1,4 +1,4 @@
-use jstz_proto::context::new_account::Addressable;
+use jstz_proto::context::account::Addressable;
 use log::{debug, info};
 
 use crate::{
diff --git a/crates/jstz_cli/src/bridge/withdraw.rs b/crates/jstz_cli/src/bridge/withdraw.rs
index 8f0a136a5..70efb534f 100644
--- a/crates/jstz_cli/src/bridge/withdraw.rs
+++ b/crates/jstz_cli/src/bridge/withdraw.rs
@@ -6,7 +6,7 @@ use crate::{
     term::styles,
     utils::AddressOrAlias,
 };
-use jstz_proto::context::new_account::Addressable;
+use jstz_proto::context::account::Addressable;
 use log::debug;
 
 pub async fn exec(
diff --git a/crates/jstz_cli/src/config.rs b/crates/jstz_cli/src/config.rs
index 1f816c4ea..f714a90da 100644
--- a/crates/jstz_cli/src/config.rs
+++ b/crates/jstz_cli/src/config.rs
@@ -3,7 +3,7 @@ use jstz_crypto::{
     public_key::PublicKey, public_key_hash::PublicKeyHash, secret_key::SecretKey,
     smart_function_hash::SmartFunctionHash,
 };
-use jstz_proto::context::new_account::NewAddress;
+use jstz_proto::context::account::Address;
 use log::debug;
 use octez::{OctezClient, OctezNode, OctezRollupNode};
 use serde::{Deserialize, Serialize};
@@ -50,7 +50,7 @@ pub enum Account {
 }
 
 impl Account {
-    pub fn address(&self) -> NewAddress {
+    pub fn address(&self) -> Address {
         match self {
             Account::User(user) => user.address.clone().into(),
             Account::SmartFunction(sf) => sf.address.clone().into(),
@@ -149,7 +149,7 @@ impl AccountConfig {
 }
 
 impl AddressOrAlias {
-    pub fn resolve(&self, cfg: &Config) -> Result<NewAddress> {
+    pub fn resolve(&self, cfg: &Config) -> Result<Address> {
         match self {
             AddressOrAlias::Address(address) => Ok(address.clone()),
             AddressOrAlias::Alias(alias) => {
@@ -166,7 +166,7 @@ impl AddressOrAlias {
     pub fn resolve_or_use_current_user(
         account: Option<AddressOrAlias>,
         cfg: &Config,
-    ) -> Result<NewAddress> {
+    ) -> Result<Address> {
         match account {
             Some(account) => account.resolve(cfg),
             None => cfg
@@ -183,7 +183,7 @@ impl AddressOrAlias {
         &self,
         cfg: &Config,
         network: &Option<NetworkName>,
-    ) -> Result<NewAddress> {
+    ) -> Result<Address> {
         match self {
             AddressOrAlias::Address(address) => Ok(address.clone()),
             AddressOrAlias::Alias(alias) => {
@@ -196,7 +196,7 @@ impl AddressOrAlias {
                         alias
                     ))?;
 
-                let address = NewAddress::from_base58(&alias_info.address)
+                let address = Address::from_base58(&alias_info.address)
                     .map_err(|e| user_error!("{}", e))?;
 
                 Ok(address)
diff --git a/crates/jstz_cli/src/deploy.rs b/crates/jstz_cli/src/deploy.rs
index 4b58f0fdd..f95cd8bba 100644
--- a/crates/jstz_cli/src/deploy.rs
+++ b/crates/jstz_cli/src/deploy.rs
@@ -1,6 +1,6 @@
 use boa_engine::JsError;
 use jstz_proto::{
-    context::new_account::ParsedCode,
+    context::account::ParsedCode,
     operation::{Content, DeployFunction, Operation, SignedOperation},
     receipt::{ReceiptContent, ReceiptResult},
 };
diff --git a/crates/jstz_cli/src/jstz.rs b/crates/jstz_cli/src/jstz.rs
index 808f5cc9f..72b58531d 100644
--- a/crates/jstz_cli/src/jstz.rs
+++ b/crates/jstz_cli/src/jstz.rs
@@ -4,7 +4,7 @@ use anyhow::{bail, Result};
 use jstz_crypto::smart_function_hash::SmartFunctionHash;
 use jstz_proto::{
     api::KvValue,
-    context::new_account::{Addressable, NewAddress, Nonce},
+    context::account::{Address, Addressable, Nonce},
     operation::{OperationHash, SignedOperation},
     receipt::Receipt,
 };
@@ -28,7 +28,7 @@ impl JstzClient {
         }
     }
 
-    pub fn logs_stream(&self, address: &NewAddress) -> EventSource {
+    pub fn logs_stream(&self, address: &Address) -> EventSource {
         let url = format!("{}/logs/{}/stream", self.endpoint, address);
         EventSource::get(url)
     }
@@ -50,7 +50,7 @@ impl JstzClient {
         }
     }
 
-    pub async fn get_nonce(&self, address: &NewAddress) -> Result<Nonce> {
+    pub async fn get_nonce(&self, address: &Address) -> Result<Nonce> {
         let response = self
             .get(&format!("{}/accounts/{}/nonce", self.endpoint, address))
             .await?;
@@ -86,7 +86,7 @@ impl JstzClient {
         }
     }
 
-    pub async fn get_balance(&self, address: &NewAddress) -> Result<u64> {
+    pub async fn get_balance(&self, address: &Address) -> Result<u64> {
         let response = self
             .get(&format!("{}/accounts/{}/balance", self.endpoint, address))
             .await?;
@@ -105,7 +105,7 @@ impl JstzClient {
 
     pub async fn get_value(
         &self,
-        address: &NewAddress,
+        address: &Address,
         key: &str,
     ) -> Result<Option<KvValue>> {
         let response = self
@@ -128,7 +128,7 @@ impl JstzClient {
 
     pub async fn get_subkey_list(
         &self,
-        address: &NewAddress,
+        address: &Address,
         key: &Option<String>,
     ) -> Result<Option<Vec<String>>> {
         let url = match key {
diff --git a/crates/jstz_cli/src/repl/debug_api/account.rs b/crates/jstz_cli/src/repl/debug_api/account.rs
index 6adab9f13..42a3a7a4e 100644
--- a/crates/jstz_cli/src/repl/debug_api/account.rs
+++ b/crates/jstz_cli/src/repl/debug_api/account.rs
@@ -6,10 +6,10 @@ use boa_engine::{
 };
 use jstz_core::runtime;
 use jstz_crypto::{hash::Hash, smart_function_hash::SmartFunctionHash};
-use jstz_proto::context::new_account::{Account, NewAddress};
+use jstz_proto::context::account::{Account, Address};
 
-fn try_parse_address(account: &str) -> JsResult<NewAddress> {
-    NewAddress::from_base58(account).map_err(|_| {
+fn try_parse_address(account: &str) -> JsResult<Address> {
+    Address::from_base58(account).map_err(|_| {
         JsNativeError::typ()
             .with_message("Could not parse the address.")
             .into()
@@ -124,7 +124,7 @@ impl AccountApi {
 
 #[cfg(test)]
 mod tests {
-    use jstz_proto::context::new_account::Addressable;
+    use jstz_proto::context::account::Addressable;
 
     use super::*;
 
@@ -135,12 +135,12 @@ mod tests {
     fn test_try_parse_address() {
         // Test valid tz1 address
         let result = try_parse_address(TEST_TZ1).unwrap();
-        assert!(matches!(result, NewAddress::User(_)));
+        assert!(matches!(result, Address::User(_)));
         assert_eq!(result.to_base58(), TEST_TZ1);
 
         // Test valid KT1 address
         let result = try_parse_address(TEST_KT1).unwrap();
-        assert!(matches!(result, NewAddress::SmartFunction(_)));
+        assert!(matches!(result, Address::SmartFunction(_)));
         assert_eq!(result.to_base58(), TEST_KT1);
     }
 
diff --git a/crates/jstz_cli/src/run.rs b/crates/jstz_cli/src/run.rs
index 39c67a2c4..7c52fd52d 100644
--- a/crates/jstz_cli/src/run.rs
+++ b/crates/jstz_cli/src/run.rs
@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use anyhow::bail;
 use http::{HeaderMap, Method, Uri};
-use jstz_proto::context::new_account::{Addressable, NewAddress};
+use jstz_proto::context::account::{Address, Addressable};
 use jstz_proto::executor::JSTZ_HOST;
 use jstz_proto::{
     operation::{Content as OperationContent, Operation, RunFunction, SignedOperation},
@@ -100,7 +100,7 @@ pub async fn exec(
 
     // 3. Construct the signed operation
     let nonce = jstz_client
-        .get_nonce(&NewAddress::User(user.address.clone()))
+        .get_nonce(&Address::User(user.address.clone()))
         .await?;
 
     // SAFETY: `url` is a valid URI since URLs are a subset of  URIs and `url_object` is a valid URL.
@@ -195,7 +195,7 @@ pub async fn exec(
     Ok(())
 }
 
-async fn spawn_trace(address: &NewAddress, jstz_client: &JstzClient) -> Result<()> {
+async fn spawn_trace(address: &Address, jstz_client: &JstzClient) -> Result<()> {
     let event_source = jstz_client.logs_stream(address);
     // need to use mpsc instead of oneshot because of the loop
     let (tx, mut rx) = mpsc::channel::<()>(1);
diff --git a/crates/jstz_cli/src/utils.rs b/crates/jstz_cli/src/utils.rs
index 0243188a1..74486beb0 100644
--- a/crates/jstz_cli/src/utils.rs
+++ b/crates/jstz_cli/src/utils.rs
@@ -1,6 +1,6 @@
 use crate::error::{Error, Result};
 use anyhow::anyhow;
-use jstz_proto::context::new_account::NewAddress;
+use jstz_proto::context::account::Address;
 use std::{
     env,
     fmt::{self, Display},
@@ -13,7 +13,7 @@ const JSTZ_ADDRESS_PREFIXES: [&str; 4] = ["tz1", "tz2", "tz3", "KT1"];
 
 #[derive(Clone, Debug)]
 pub enum AddressOrAlias {
-    Address(NewAddress),
+    Address(Address),
     Alias(String),
 }
 
@@ -28,7 +28,7 @@ impl FromStr for AddressOrAlias {
         if is_jstz_address {
             Ok(Self::Address(
                 address_or_alias
-                    .parse::<NewAddress>()
+                    .parse::<Address>()
                     .map_err(|e| anyhow!("{}", e))?,
             ))
         } else {
@@ -102,15 +102,12 @@ mod tests {
         let result = AddressOrAlias::from_str(TEST_KT1).unwrap();
         assert!(matches!(
             result,
-            AddressOrAlias::Address(NewAddress::SmartFunction(_))
+            AddressOrAlias::Address(Address::SmartFunction(_))
         ));
 
         // Test valid tz1 address
         let result = AddressOrAlias::from_str(TEST_TZ1).unwrap();
-        assert!(matches!(
-            result,
-            AddressOrAlias::Address(NewAddress::User(_))
-        ));
+        assert!(matches!(result, AddressOrAlias::Address(Address::User(_))));
 
         // Test alias
         let result = AddressOrAlias::from_str(TEST_ALIAS).unwrap();
diff --git a/crates/jstz_kernel/src/inbox.rs b/crates/jstz_kernel/src/inbox.rs
index 28d8ac518..33d415b74 100644
--- a/crates/jstz_kernel/src/inbox.rs
+++ b/crates/jstz_kernel/src/inbox.rs
@@ -1,5 +1,5 @@
 use jstz_core::BinEncodable;
-use jstz_proto::context::new_account::NewAddress;
+use jstz_proto::context::account::Address;
 use jstz_proto::operation::{external::Deposit, ExternalOperation, SignedOperation};
 use num_traits::ToPrimitive;
 use tezos_crypto_rs::hash::ContractKt1Hash;
@@ -82,7 +82,7 @@ fn read_transfer(
             if is_valid_native_deposit(rt, &ticket, ticketer) {
                 let amount = ticket.amount().to_u64()?;
                 let address = tez_ticket.0 .0.to_b58check();
-                let receiver = NewAddress::from_base58(&address).ok()?;
+                let receiver = Address::from_base58(&address).ok()?;
                 let content = Deposit {
                     inbox_id,
                     amount,
@@ -195,7 +195,7 @@ mod test {
     use jstz_crypto::smart_function_hash::SmartFunctionHash;
     use jstz_mock::message::native_deposit::MockNativeDeposit;
     use jstz_mock::{host::JstzMockHost, message::fa_deposit::MockFaDeposit};
-    use jstz_proto::context::new_account::{Addressable, NewAddress};
+    use jstz_proto::context::account::{Address, Addressable};
     use jstz_proto::operation::external;
     use tezos_crypto_rs::hash::{ContractKt1Hash, HashTrait};
     use tezos_smart_rollup::types::SmartRollupAddress;
@@ -299,8 +299,8 @@ mod test {
                 ),
                 proxy_smart_function.map(|p| {
                     match p {
-                        NewAddress::User(_) => panic!("Unexpected proxy"),
-                        NewAddress::SmartFunction(sfh) => sfh,
+                        Address::User(_) => panic!("Unexpected proxy"),
+                        Address::SmartFunction(sfh) => sfh,
                     }
                 })
             );
diff --git a/crates/jstz_kernel/src/lib.rs b/crates/jstz_kernel/src/lib.rs
index 7cd72a52d..5ce0cd652 100644
--- a/crates/jstz_kernel/src/lib.rs
+++ b/crates/jstz_kernel/src/lib.rs
@@ -66,8 +66,8 @@ mod test {
         message::{fa_deposit::MockFaDeposit, native_deposit::MockNativeDeposit},
     };
     use jstz_proto::context::{
-        new_account::NewAddress,
-        new_account::{Account, ParsedCode},
+        account::Address,
+        account::{Account, ParsedCode},
         ticket_table::TicketTable,
     };
     use tezos_smart_rollup::types::{Contract, PublicKeyHash};
@@ -95,7 +95,7 @@ mod test {
                 let amount = Account::balance(
                     host.rt(),
                     tx,
-                    &NewAddress::User(jstz_crypto::public_key_hash::PublicKeyHash::Tz1(
+                    &Address::User(jstz_crypto::public_key_hash::PublicKeyHash::Tz1(
                         tz1.into(),
                     )),
                 )
@@ -118,7 +118,7 @@ mod test {
         let proxy = crate::executor::smart_function::Script::deploy(
             host.rt(),
             tx,
-            &NewAddress::User(
+            &Address::User(
                 jstz_crypto::public_key_hash::PublicKeyHash::from_base58(MOCK_SOURCE)
                     .unwrap(),
             ),
@@ -142,7 +142,7 @@ mod test {
                 let proxy_balance = TicketTable::get_balance(
                     host.rt(),
                     tx,
-                    &NewAddress::SmartFunction(proxy),
+                    &Address::SmartFunction(proxy),
                     &ticket_hash,
                 )
                 .unwrap();
@@ -173,7 +173,7 @@ mod test {
                 let proxy_balance = TicketTable::get_balance(
                     host.rt(),
                     &mut tx,
-                    &NewAddress::SmartFunction(proxy),
+                    &Address::SmartFunction(proxy),
                     &ticket_hash,
                 )
                 .unwrap();
diff --git a/crates/jstz_kernel/src/parsing.rs b/crates/jstz_kernel/src/parsing.rs
index f6615acd9..aecf96782 100644
--- a/crates/jstz_kernel/src/parsing.rs
+++ b/crates/jstz_kernel/src/parsing.rs
@@ -1,17 +1,17 @@
 use jstz_crypto::public_key_hash::PublicKeyHash;
 use jstz_crypto::smart_function_hash::SmartFunctionHash;
 use jstz_proto::operation::external::FaDeposit;
-use jstz_proto::{context::new_account::NewAddress, Result};
+use jstz_proto::{context::account::Address, Result};
 use num_traits::ToPrimitive;
 use tezos_smart_rollup::michelson::{ticket::FA2_1Ticket, MichelsonContract};
 use tezos_smart_rollup::types::{Contract, PublicKeyHash as TezosPublicKeyHash};
 
-pub fn try_parse_contract(contract: &Contract) -> Result<NewAddress> {
+pub fn try_parse_contract(contract: &Contract) -> Result<Address> {
     match contract {
         Contract::Implicit(TezosPublicKeyHash::Ed25519(tz1)) => {
-            Ok(NewAddress::User(PublicKeyHash::Tz1(tz1.clone().into())))
+            Ok(Address::User(PublicKeyHash::Tz1(tz1.clone().into())))
         }
-        Contract::Originated(contract_kt1_hash) => Ok(NewAddress::SmartFunction(
+        Contract::Originated(contract_kt1_hash) => Ok(Address::SmartFunction(
             SmartFunctionHash(contract_kt1_hash.clone()),
         )),
         _ => Err(jstz_proto::Error::InvalidAddress),
@@ -28,7 +28,7 @@ pub fn try_parse_fa_deposit(
 
     let proxy_smart_function = (proxy_contract)
         .map(|c| {
-            if let addr @ NewAddress::SmartFunction(_) = try_parse_contract(&c.0)? {
+            if let addr @ Address::SmartFunction(_) = try_parse_contract(&c.0)? {
                 Ok(addr)
             } else {
                 Err(jstz_proto::Error::AddressTypeMismatch)
@@ -56,7 +56,7 @@ mod test {
 
     use jstz_crypto::smart_function_hash::SmartFunctionHash;
     use jstz_proto::{
-        context::new_account::{Addressable, NewAddress},
+        context::account::{Address, Addressable},
         operation::external::FaDeposit,
     };
     use tezos_smart_rollup::{
@@ -102,10 +102,8 @@ mod test {
         let expected = FaDeposit {
             inbox_id,
             amount,
-            receiver: NewAddress::User(jstz_mock::account1()),
-            proxy_smart_function: Some(NewAddress::SmartFunction(
-                jstz_mock::sf_account1(),
-            )),
+            receiver: Address::User(jstz_mock::account1()),
+            proxy_smart_function: Some(Address::SmartFunction(jstz_mock::sf_account1())),
             ticket_hash,
         };
         assert_eq!(expected, fa_deposit)
diff --git a/crates/jstz_node/src/services/accounts.rs b/crates/jstz_node/src/services/accounts.rs
index 5a5de62f8..ab8e9463e 100644
--- a/crates/jstz_node/src/services/accounts.rs
+++ b/crates/jstz_node/src/services/accounts.rs
@@ -6,7 +6,7 @@ use axum::{
 use jstz_core::BinEncodable;
 use jstz_proto::{
     api::KvValue,
-    context::new_account::{
+    context::account::{
         Account, Nonce, ParsedCode, SmartFunctionAccount, UserAccount,
         ACCOUNTS_PATH_PREFIX,
     },
diff --git a/crates/jstz_node/src/services/logs/db.rs b/crates/jstz_node/src/services/logs/db.rs
index 3b60376dd..ea1974db5 100644
--- a/crates/jstz_node/src/services/logs/db.rs
+++ b/crates/jstz_node/src/services/logs/db.rs
@@ -6,7 +6,7 @@ use anyhow::{anyhow, Result};
 use jstz_api::js_log::LogLevel;
 use jstz_crypto::public_key_hash::PublicKeyHash;
 use jstz_proto::{
-    context::new_account::NewAddress, js_logger::LogRecord, request_logger::RequestEvent,
+    context::account::Address, js_logger::LogRecord, request_logger::RequestEvent,
 };
 use r2d2::{Pool, PooledConnection};
 use r2d2_sqlite::SqliteConnectionManager;
@@ -103,7 +103,7 @@ impl Db {
 
     pub async fn logs_by_address(
         &self,
-        function_address: NewAddress,
+        function_address: Address,
         limit: usize,
         offset: usize,
     ) -> QueryResponseResult {
@@ -117,7 +117,7 @@ impl Db {
 
     pub async fn logs_by_address_and_request_id(
         &self,
-        function_address: NewAddress,
+        function_address: Address,
         request_id: String,
     ) -> QueryResponseResult {
         let conn = self.connection().await?;
diff --git a/crates/jstz_node/src/services/logs/mod.rs b/crates/jstz_node/src/services/logs/mod.rs
index e8c0471a7..e7d94f31f 100644
--- a/crates/jstz_node/src/services/logs/mod.rs
+++ b/crates/jstz_node/src/services/logs/mod.rs
@@ -50,14 +50,14 @@ mod persistent_logging {
         extract::{Path, Query, State},
         Json,
     };
-    use jstz_proto::context::new_account::NewAddress;
+    use jstz_proto::context::account::Address;
 
     pub async fn persistent_logs(
         State(AppState { db, .. }): State<AppState>,
         Path(address): Path<String>,
         Query(Pagination { limit, offset }): Query<Pagination>,
     ) -> ServiceResult<Json<Vec<LogRecord>>> {
-        let address = NewAddress::from_base58(&address)
+        let address = Address::from_base58(&address)
             .map_err(|e| ServiceError::BadRequest(e.to_string()))?;
         let result = db.logs_by_address(address, offset, limit).await?;
 
@@ -69,7 +69,7 @@ mod persistent_logging {
         Path(address): Path<String>,
         Path(request_id): Path<String>,
     ) -> ServiceResult<Json<Vec<LogRecord>>> {
-        let address = NewAddress::from_base58(&address)
+        let address = Address::from_base58(&address)
             .map_err(|e| ServiceError::BadRequest(e.to_string()))?;
 
         let result = db
diff --git a/crates/jstz_proto/src/api/ledger.rs b/crates/jstz_proto/src/api/ledger.rs
index 6d842fe02..223ef8bc2 100644
--- a/crates/jstz_proto/src/api/ledger.rs
+++ b/crates/jstz_proto/src/api/ledger.rs
@@ -15,7 +15,7 @@ use jstz_core::{
 use jstz_crypto::smart_function_hash::SmartFunctionHash;
 
 use crate::{
-    context::new_account::{Account, Amount, NewAddress},
+    context::account::{Account, Address, Amount},
     error::Result,
 };
 
@@ -42,7 +42,7 @@ impl Ledger {
     fn balance(
         rt: &impl HostRuntime,
         tx: &mut Transaction,
-        addr: &NewAddress,
+        addr: &Address,
     ) -> Result<u64> {
         let balance = Account::balance(rt, tx, addr)?;
 
@@ -53,7 +53,7 @@ impl Ledger {
         &self,
         rt: &impl HostRuntime,
         tx: &mut Transaction,
-        dst: &NewAddress,
+        dst: &Address,
         amount: Amount,
     ) -> Result<()> {
         Account::transfer(rt, tx, &self.address, dst, amount)?;
@@ -66,7 +66,7 @@ pub struct LedgerApi {
     pub address: SmartFunctionHash,
 }
 
-pub(crate) fn js_value_to_pkh(value: &JsValue) -> Result<NewAddress> {
+pub(crate) fn js_value_to_pkh(value: &JsValue) -> Result<Address> {
     let pkh_string = value
         .as_string()
         .ok_or_else(|| {
@@ -75,7 +75,7 @@ pub(crate) fn js_value_to_pkh(value: &JsValue) -> Result<NewAddress> {
         })
         .map(JsString::to_std_string_escaped)?;
 
-    NewAddress::from_base58(&pkh_string)
+    Address::from_base58(&pkh_string)
 }
 
 impl Ledger {
diff --git a/crates/jstz_proto/src/api/smart_function.rs b/crates/jstz_proto/src/api/smart_function.rs
index efdd61a48..56d95678c 100644
--- a/crates/jstz_proto/src/api/smart_function.rs
+++ b/crates/jstz_proto/src/api/smart_function.rs
@@ -15,7 +15,7 @@ use jstz_core::{
 use jstz_crypto::{hash::Hash, smart_function_hash::SmartFunctionHash};
 
 use crate::{
-    context::new_account::{Account, Amount, NewAddress, ParsedCode},
+    context::account::{Account, Address, Amount, ParsedCode},
     executor::{
         smart_function::{headers, HostScript, Script},
         JSTZ_HOST,
@@ -76,7 +76,7 @@ impl SmartFunction {
         }
 
         // 2. Deploy the smart function
-        let deployed = NewAddress::SmartFunction(Script::deploy(
+        let deployed = Address::SmartFunction(Script::deploy(
             hrt,
             tx,
             deployer,
@@ -113,10 +113,7 @@ impl SmartFunction {
                         )
                     })?;
                 // 2. Set the referrer of the request to the current smart function address
-                headers::test_and_set_referrer(
-                    &request_deref,
-                    &NewAddress::SmartFunction(self_address.clone()),
-                )?;
+                headers::test_and_set_referrer(&request_deref, self_address)?;
 
                 // 3. Load, init and run!
                 Script::load_init_run(
@@ -280,8 +277,8 @@ mod test {
 
     use crate::{
         context::{
-            new_account::NewAddress,
-            new_account::{Account, ParsedCode},
+            account::Address,
+            account::{Account, ParsedCode},
             ticket_table::TicketTable,
         },
         executor::smart_function::{self, register_web_apis, Script},
@@ -306,8 +303,7 @@ mod test {
         let amount = 100;
 
         let operation_hash = Blake2b::from(b"operation_hash".as_ref());
-        let receiver =
-            NewAddress::User(PublicKeyHash::digest(b"receiver address").unwrap());
+        let receiver = Address::User(PublicKeyHash::digest(b"receiver address").unwrap());
         let http_request = http::Request::builder()
             .method(Method::POST)
             .uri("tezos://jstz/withdraw")
@@ -348,7 +344,7 @@ mod test {
         let mut mock_host = JstzMockHost::default();
         let host = mock_host.rt();
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let code = r#"
         export default (request) => {
             const withdrawRequest = new Request("tezos://jstz/withdraw", {
@@ -417,8 +413,8 @@ mod test {
 
     #[test]
     fn host_script_fa_withdraw_from_smart_function_succeeds() {
-        let receiver = NewAddress::User(jstz_mock::account1());
-        let source = NewAddress::User(jstz_mock::account2());
+        let receiver = Address::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account2());
         let ticketer = jstz_mock::kt1_account1();
         let ticketer_string = ticketer.clone();
         let l1_proxy_contract = ticketer.clone();
@@ -517,7 +513,7 @@ mod test {
         let balance = TicketTable::get_balance(
             host,
             &mut tx,
-            &NewAddress::SmartFunction(token_smart_function),
+            &Address::SmartFunction(token_smart_function),
             &ticket_hash,
         )
         .unwrap();
diff --git a/crates/jstz_proto/src/context/new_account.rs b/crates/jstz_proto/src/context/account.rs
similarity index 88%
rename from crates/jstz_proto/src/context/new_account.rs
rename to crates/jstz_proto/src/context/account.rs
index d006989be..c0a2d55bd 100644
--- a/crates/jstz_proto/src/context/new_account.rs
+++ b/crates/jstz_proto/src/context/account.rs
@@ -88,18 +88,18 @@ pub enum AddressKind {
 
 // Represents the address in jstz, which can be converted to a base58 string.
 // This is required to avoid unnecessary cloning when getting the key path for the Account.
-pub trait Addressable: Into<NewAddress> + Clone {
+pub trait Addressable: Into<Address> + Clone {
     fn kind(&self) -> AddressKind;
     fn to_base58(&self) -> String;
 }
 
-impl From<SmartFunctionHash> for NewAddress {
+impl From<SmartFunctionHash> for Address {
     fn from(sfh: SmartFunctionHash) -> Self {
         Self::SmartFunction(sfh)
     }
 }
 
-impl From<PublicKeyHash> for NewAddress {
+impl From<PublicKeyHash> for Address {
     fn from(pkh: PublicKeyHash) -> Self {
         Self::User(pkh)
     }
@@ -138,21 +138,18 @@ impl Addressable for PublicKeyHash {
     Encode,
     Decode,
 )]
-// TODO: rename to Address
-// https://linear.app/tezos/issue/JSTZ-253/remove-old-accountrs
-#[schema(as = Address)]
 #[schema(description = "Tezos Address")]
 #[serde(untagged)]
-pub enum NewAddress {
+pub enum Address {
     User(PublicKeyHash),
     SmartFunction(SmartFunctionHash),
 }
 
-unsafe impl Trace for NewAddress {
+unsafe impl Trace for Address {
     empty_trace!();
 }
 
-impl Display for NewAddress {
+impl Display for Address {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::User(hash) => hash.fmt(f),
@@ -161,7 +158,7 @@ impl Display for NewAddress {
     }
 }
 
-impl FromStr for NewAddress {
+impl FromStr for Address {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self> {
@@ -169,7 +166,7 @@ impl FromStr for NewAddress {
     }
 }
 
-impl Addressable for NewAddress {
+impl Addressable for Address {
     fn kind(&self) -> AddressKind {
         match self {
             Self::User(_) => AddressKind::User,
@@ -185,7 +182,7 @@ impl Addressable for NewAddress {
     }
 }
 
-impl NewAddress {
+impl Address {
     pub fn as_smart_function(&self) -> Option<&SmartFunctionHash> {
         match self {
             Self::SmartFunction(sfh) => Some(sfh),
@@ -198,20 +195,18 @@ impl NewAddress {
             return Err(Error::InvalidAddress);
         }
         match &data[..3] {
-            "KT1" => Ok(NewAddress::SmartFunction(SmartFunctionHash::from_base58(
+            "KT1" => Ok(Address::SmartFunction(SmartFunctionHash::from_base58(
                 data,
             )?)),
-            "tz1" | "tz2" | "tz3" => {
-                Ok(NewAddress::User(PublicKeyHash::from_base58(data)?))
-            }
+            "tz1" | "tz2" | "tz3" => Ok(Address::User(PublicKeyHash::from_base58(data)?)),
             _ => Err(Error::InvalidAddress),
         }
     }
 
     pub fn as_bytes(&self) -> &[u8] {
         match self {
-            NewAddress::User(hash) => hash.as_bytes(),
-            NewAddress::SmartFunction(hash) => hash.as_bytes(),
+            Address::User(hash) => hash.as_bytes(),
+            Address::SmartFunction(hash) => hash.as_bytes(),
         }
     }
 }
@@ -443,31 +438,31 @@ mod test {
         #[test]
         fn test_from_str_all_types() {
             // Test tz1 (Ed25519)
-            let tz1_addr = NewAddress::from_str(TZ1).unwrap();
+            let tz1_addr = Address::from_str(TZ1).unwrap();
             assert!(matches!(
                 &tz1_addr,
-                NewAddress::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ1
+                Address::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ1
             ));
 
             // Test tz2 (Secp256k1)
-            let tz2_addr = NewAddress::from_str(TZ2).unwrap();
+            let tz2_addr = Address::from_str(TZ2).unwrap();
             assert!(matches!(
                 &tz2_addr,
-                NewAddress::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ2
+                Address::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ2
             ));
 
             // Test tz3 (P256)
-            let tz3_addr = NewAddress::from_str(TZ3).unwrap();
+            let tz3_addr = Address::from_str(TZ3).unwrap();
             assert!(matches!(
                 &tz3_addr,
-                NewAddress::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ3
+                Address::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ3
             ));
 
             // Test KT1 (Smart Function)
-            let kt1_addr = NewAddress::from_str(KT1).unwrap();
+            let kt1_addr = Address::from_str(KT1).unwrap();
             assert!(matches!(
                 &kt1_addr,
-                NewAddress::SmartFunction(ref hash) if <SmartFunctionHash as Hash>::to_base58(hash) == KT1
+                Address::SmartFunction(ref hash) if <SmartFunctionHash as Hash>::to_base58(hash) == KT1
             ));
         }
 
@@ -475,76 +470,76 @@ mod test {
         fn test_invalid_addresses() {
             // Test invalid prefix
             assert!(matches!(
-                NewAddress::from_str("tx1abc123"),
+                Address::from_str("tx1abc123"),
                 Err(Error::InvalidAddress)
             ));
 
             // Test invalid tz1
-            assert!(NewAddress::from_str("tz1invalid").is_err());
+            assert!(Address::from_str("tz1invalid").is_err());
 
             // Test invalid tz2
-            assert!(NewAddress::from_str("tz2invalid").is_err());
+            assert!(Address::from_str("tz2invalid").is_err());
 
             // Test invalid tz3
-            assert!(NewAddress::from_str("tz3invalid").is_err());
+            assert!(Address::from_str("tz3invalid").is_err());
 
             // Test invalid KT1
-            assert!(NewAddress::from_str("KT1invalid").is_err());
+            assert!(Address::from_str("KT1invalid").is_err());
         }
 
         #[test]
         fn test_display() {
             // Test tz1 display
-            let tz1_addr = NewAddress::from_str(TZ1).unwrap();
+            let tz1_addr = Address::from_str(TZ1).unwrap();
             assert_eq!(tz1_addr.to_string(), TZ1);
 
             // Test tz2 display
-            let tz2_addr = NewAddress::from_str(TZ2).unwrap();
+            let tz2_addr = Address::from_str(TZ2).unwrap();
             assert_eq!(tz2_addr.to_string(), TZ2);
 
             // Test tz3 display
-            let tz3_addr = NewAddress::from_str(TZ3).unwrap();
+            let tz3_addr = Address::from_str(TZ3).unwrap();
             assert_eq!(tz3_addr.to_string(), TZ3);
 
             // Test KT1 display
-            let kt1_addr = NewAddress::from_str(KT1).unwrap();
+            let kt1_addr = Address::from_str(KT1).unwrap();
             assert_eq!(kt1_addr.to_string(), KT1);
         }
 
         #[test]
         fn test_from_base58() {
             // Test valid addresses
-            let tz1_addr = NewAddress::from_base58(TZ1).unwrap();
+            let tz1_addr = Address::from_base58(TZ1).unwrap();
             assert!(matches!(
                 &tz1_addr,
-                NewAddress::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ1
+                Address::User(ref pkh) if <PublicKeyHash as Hash>::to_base58(pkh) == TZ1
             ));
 
-            let kt1_addr = NewAddress::from_base58(KT1).unwrap();
+            let kt1_addr = Address::from_base58(KT1).unwrap();
             assert!(matches!(
                 &kt1_addr,
-                NewAddress::SmartFunction(ref hash) if <SmartFunctionHash as Hash>::to_base58(hash) == KT1
+                Address::SmartFunction(ref hash) if <SmartFunctionHash as Hash>::to_base58(hash) == KT1
             ));
 
             // Test invalid prefixes
             assert!(matches!(
-                NewAddress::from_base58("tx1abc123"),
+                Address::from_base58("tx1abc123"),
                 Err(Error::InvalidAddress)
             ));
 
             // Test invalid formats
-            assert!(NewAddress::from_base58("tz1invalid").is_err());
-            assert!(NewAddress::from_base58("KT1invalid").is_err());
+            assert!(Address::from_base58("tz1invalid").is_err());
+            assert!(Address::from_base58("KT1invalid").is_err());
 
             // Test empty string
             assert!(matches!(
-                NewAddress::from_base58(""),
+                Address::from_base58(""),
                 Err(Error::InvalidAddress)
             ));
 
             // Test string too short for prefix check
             assert!(matches!(
-                NewAddress::from_base58("tz"),
+                Address::from_base58("tz"),
                 Err(Error::InvalidAddress)
             ));
         }
@@ -552,44 +547,44 @@ mod test {
         #[test]
         fn test_from_base58_error() {
             let invalid_checksum = "tz1cD5CuvAALcxgypqBXcBQEA8dkLJivoFjV"; // Changed last char
-            let result = NewAddress::from_base58(invalid_checksum);
+            let result = Address::from_base58(invalid_checksum);
             assert!(result.is_err());
 
             let invalid_kt1 = "KT1TxqZ8QtKvLu3V3JH7Gx58n7Co8pgtpQU6"; // Changed last char
-            let result = NewAddress::from_base58(invalid_kt1);
+            let result = Address::from_base58(invalid_kt1);
             assert!(result.is_err());
         }
 
         #[test]
         fn test_to_base58() {
             // Test User addresses
-            let tz1_addr = NewAddress::from_str(TZ1).unwrap();
+            let tz1_addr = Address::from_str(TZ1).unwrap();
             assert_eq!(tz1_addr.to_base58(), TZ1);
 
-            let tz2_addr = NewAddress::from_str(TZ2).unwrap();
+            let tz2_addr = Address::from_str(TZ2).unwrap();
             assert_eq!(tz2_addr.to_base58(), TZ2);
 
-            let tz3_addr = NewAddress::from_str(TZ3).unwrap();
+            let tz3_addr = Address::from_str(TZ3).unwrap();
             assert_eq!(tz3_addr.to_base58(), TZ3);
 
             // Test SmartFunction address
-            let kt1_addr = NewAddress::from_str(KT1).unwrap();
+            let kt1_addr = Address::from_str(KT1).unwrap();
             assert_eq!(kt1_addr.to_base58(), KT1);
 
             // Test roundtrip
-            let addr = NewAddress::from_base58(&kt1_addr.to_base58()).unwrap();
+            let addr = Address::from_base58(&kt1_addr.to_base58()).unwrap();
             assert_eq!(addr, kt1_addr);
         }
 
         #[test]
         fn test_as_bytes() {
             // Test User address bytes
-            let tz1_addr = NewAddress::from_str(TZ1).unwrap();
+            let tz1_addr = Address::from_str(TZ1).unwrap();
             let tz1_bytes = tz1_addr.as_bytes();
             assert!(!tz1_bytes.is_empty());
 
             // Test SmartFunction address bytes
-            let kt1_addr = NewAddress::from_str(KT1).unwrap();
+            let kt1_addr = Address::from_str(KT1).unwrap();
             let kt1_bytes = kt1_addr.as_bytes();
             assert!(!kt1_bytes.is_empty());
 
@@ -609,9 +604,9 @@ mod test {
             (host, tx)
         }
 
-        fn create_test_addresses() -> (NewAddress, NewAddress) {
-            let user_addr = NewAddress::from_str(TZ1).unwrap();
-            let sf_addr = NewAddress::from_str(KT1).unwrap();
+        fn create_test_addresses() -> (Address, Address) {
+            let user_addr = Address::from_str(TZ1).unwrap();
+            let sf_addr = Address::from_str(KT1).unwrap();
             (user_addr, sf_addr)
         }
 
@@ -627,7 +622,7 @@ mod test {
             assert_eq!(sf_path.to_string(), format!("/jstz_account/{}", KT1));
 
             // Test path validation
-            let addr = NewAddress::User(
+            let addr = Address::User(
                 PublicKeyHash::from_base58("tz1cD5CuvAALcxgypqBXcBQEA8dkLJivoFjU")
                     .unwrap(),
             );
@@ -778,7 +773,7 @@ mod test {
 
             // Extract the smart function hash for testing
             let sf_hash = match &sf_addr {
-                NewAddress::SmartFunction(hash) => hash,
+                Address::SmartFunction(hash) => hash,
                 _ => panic!("Expected SmartFunction address"),
             };
 
@@ -911,7 +906,7 @@ mod test {
             )
             .unwrap();
 
-            let sf_addr = NewAddress::SmartFunction(sf_hash);
+            let sf_addr = Address::SmartFunction(sf_hash);
             let account = Account::get_mut(&host, &mut tx, &sf_addr).unwrap();
             match account {
                 Account::SmartFunction(sf_account) => {
diff --git a/crates/jstz_proto/src/context/mod.rs b/crates/jstz_proto/src/context/mod.rs
index 331dc772f..2933a2fe3 100644
--- a/crates/jstz_proto/src/context/mod.rs
+++ b/crates/jstz_proto/src/context/mod.rs
@@ -1,5 +1,3 @@
-// TODO: remove account and rename new_account to account
-// https://linear.app/tezos/issue/JSTZ-253/remove-old-accountrs
-pub mod new_account;
+pub mod account;
 pub mod receipt;
 pub mod ticket_table;
diff --git a/crates/jstz_proto/src/context/ticket_table.rs b/crates/jstz_proto/src/context/ticket_table.rs
index 3ef3b0b71..d2999f77d 100644
--- a/crates/jstz_proto/src/context/ticket_table.rs
+++ b/crates/jstz_proto/src/context/ticket_table.rs
@@ -6,7 +6,7 @@ use tezos_smart_rollup::{
     storage::path::{self, OwnedPath, RefPath},
 };
 
-use super::new_account::{Addressable, Amount};
+use super::account::{Addressable, Amount};
 
 use crate::error::Result;
 
@@ -101,7 +101,7 @@ impl TicketTable {
 
 #[cfg(test)]
 mod test {
-    use crate::context::new_account::NewAddress;
+    use crate::context::account::Address;
 
     use super::*;
     use jstz_core::kv::Transaction;
@@ -112,15 +112,15 @@ mod test {
     use jstz_mock::host::JstzMockHost;
     use tezos_smart_rollup_mock::MockHost;
 
-    fn user_address() -> NewAddress {
-        NewAddress::User(
+    fn user_address() -> Address {
+        Address::User(
             PublicKeyHash::from_base58("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx")
                 .expect("Could not parse pkh"),
         )
     }
 
-    fn smart_function_address() -> NewAddress {
-        NewAddress::SmartFunction(
+    fn smart_function_address() -> Address {
+        Address::SmartFunction(
             SmartFunctionHash::from_base58("KT1RycYvM4EVs6BAXWEsGXaAaRqiMP53KT4w")
                 .expect("Could not parse smart function hash"),
         )
diff --git a/crates/jstz_proto/src/executor/deposit.rs b/crates/jstz_proto/src/executor/deposit.rs
index a53a847c7..aca60dc26 100644
--- a/crates/jstz_proto/src/executor/deposit.rs
+++ b/crates/jstz_proto/src/executor/deposit.rs
@@ -2,7 +2,7 @@ use jstz_core::{host::HostRuntime, kv::Transaction};
 use jstz_crypto::hash::Blake2b;
 
 use crate::{
-    context::new_account::Account,
+    context::account::Account,
     operation::external::Deposit,
     receipt::{DepositReceipt, Receipt},
 };
@@ -35,7 +35,7 @@ mod test {
     use tezos_smart_rollup_mock::MockHost;
 
     use crate::{
-        context::new_account::NewAddress,
+        context::account::Address,
         operation::external::Deposit,
         receipt::{DepositReceipt, ReceiptContent, ReceiptResult},
     };
@@ -50,7 +50,7 @@ mod test {
         let deposit = Deposit {
             inbox_id: 1,
             amount: 20,
-            receiver: NewAddress::User(receiver.clone()),
+            receiver: Address::User(receiver.clone()),
         };
         tx.begin();
         let receipt = execute(&mut host, &mut tx, deposit);
@@ -59,7 +59,7 @@ mod test {
             ReceiptResult::Success(ReceiptContent::Deposit(DepositReceipt {
                 account,
                 updated_balance,
-            })) if account == NewAddress::User(receiver) && updated_balance == 20
+            })) if account == Address::User(receiver) && updated_balance == 20
         ));
         let raw_json_payload = r#"{"hash":[39,12,7,148,87,7,176,168,111,219,214,147,14,123,179,202,232,151,138,59,207,182,101,158,128,98,239,57,236,88,195,42],"result":{"_type":"Success","inner":{"_type":"Deposit","account":"tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx","updated_balance":20}}}"#;
         assert_eq!(raw_json_payload, serde_json::to_string(&receipt).unwrap());
diff --git a/crates/jstz_proto/src/executor/fa_deposit.rs b/crates/jstz_proto/src/executor/fa_deposit.rs
index e6e5919a8..57ea0be54 100644
--- a/crates/jstz_proto/src/executor/fa_deposit.rs
+++ b/crates/jstz_proto/src/executor/fa_deposit.rs
@@ -9,7 +9,7 @@ use tezos_smart_rollup::{michelson::ticket::TicketHash, prelude::debug_msg};
 use utoipa::ToSchema;
 
 use crate::{
-    context::{new_account::Amount, new_account::NewAddress, ticket_table::TicketTable},
+    context::{account::Address, account::Amount, ticket_table::TicketTable},
     executor::smart_function,
     operation::{external::FaDeposit, RunFunction},
     receipt::Receipt,
@@ -25,7 +25,7 @@ const DEPOSIT_URI: &str = "/-/deposit";
 
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema, Encode, Decode)]
 pub struct FaDepositReceipt {
-    pub receiver: NewAddress,
+    pub receiver: Address,
     pub ticket_balance: Amount,
     #[bincode(with_serde)]
     pub run_function: Option<crate::receipt::RunFunctionReceipt>,
@@ -40,7 +40,7 @@ pub enum FaDepositError {
 fn deposit_to_receiver(
     rt: &mut impl HostRuntime,
     tx: &mut Transaction,
-    receiver: &NewAddress,
+    receiver: &Address,
     ticket_hash: &TicketHash,
     amount: Amount,
 ) -> Result<FaDepositReceipt> {
@@ -54,7 +54,7 @@ fn deposit_to_receiver(
 
 fn new_run_function(
     http_body: HttpBody,
-    proxy_contract: &NewAddress,
+    proxy_contract: &Address,
 ) -> Result<RunFunction> {
     let mut headers = HeaderMap::new();
     headers.insert(
@@ -81,17 +81,12 @@ fn deposit_to_proxy_contract(
     rt: &mut impl HostRuntime,
     tx: &mut Transaction,
     deposit: &FaDeposit,
-    proxy_contract: &NewAddress,
+    proxy_contract: &Address,
 ) -> Result<FaDepositReceipt> {
     let run = new_run_function(deposit.to_http_body(), proxy_contract)?;
     let source = PublicKeyHash::from_base58(NULL_ADDRESS)?;
-    let result = smart_function::run::execute(
-        rt,
-        tx,
-        &NewAddress::User(source),
-        run,
-        deposit.hash(),
-    );
+    let result =
+        smart_function::run::execute(rt, tx, &Address::User(source), run, deposit.hash());
     match result {
         Ok(run_receipt) => {
             if run_receipt.status_code.is_success() {
@@ -179,9 +174,7 @@ mod test {
     use tezos_smart_rollup_mock::MockHost;
 
     use crate::{
-        context::{
-            new_account::NewAddress, new_account::ParsedCode, ticket_table::TicketTable,
-        },
+        context::{account::Address, account::ParsedCode, ticket_table::TicketTable},
         executor::fa_deposit::{FaDeposit, FaDepositReceipt},
         receipt::{Receipt, ReceiptContent, ReceiptResult},
     };
@@ -190,8 +183,8 @@ mod test {
         FaDeposit {
             inbox_id: 34,
             amount: 42,
-            receiver: NewAddress::User(jstz_mock::account2()),
-            proxy_smart_function: proxy.map(NewAddress::SmartFunction),
+            receiver: Address::User(jstz_mock::account2()),
+            proxy_smart_function: proxy.map(Address::SmartFunction),
             ticket_hash: jstz_mock::ticket_hash1(),
         }
     }
@@ -276,7 +269,7 @@ mod test {
         let mut host = MockHost::default();
         host.set_debug_handler(empty());
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let code = r#"
         export default (request) => {
             const url = new URL(request.url)
@@ -310,12 +303,12 @@ mod test {
                 run_function,
             })) => {
                 assert_eq!(42, ticket_balance);
-                assert_eq!(NewAddress::SmartFunction(proxy.clone()), receiver);
+                assert_eq!(Address::SmartFunction(proxy.clone()), receiver);
                 assert!(run_function.is_some());
                 let balance = TicketTable::get_balance(
                     &mut host,
                     &mut tx,
-                    &NewAddress::SmartFunction(proxy),
+                    &Address::SmartFunction(proxy),
                     &ticket_hash,
                 )
                 .unwrap();
@@ -330,7 +323,7 @@ mod test {
         let mut host = MockHost::default();
         host.set_debug_handler(empty());
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let code = r#"
         export default (request) => {
             const url = new URL(request.url)
@@ -368,12 +361,12 @@ mod test {
                 run_function,
             })) => {
                 assert_eq!(84, ticket_balance);
-                assert_eq!(NewAddress::SmartFunction(proxy.clone()), receiver);
+                assert_eq!(Address::SmartFunction(proxy.clone()), receiver);
                 assert!(run_function.is_some());
                 let balance = TicketTable::get_balance(
                     &mut host,
                     &mut tx,
-                    &NewAddress::SmartFunction(proxy),
+                    &Address::SmartFunction(proxy),
                     &ticket_hash,
                 )
                 .unwrap();
@@ -389,7 +382,7 @@ mod test {
         host.set_debug_handler(empty());
         let mut tx = Transaction::default();
         tx.begin();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let code = r#"
         export default (request) => {
             const url = new URL(request.url)
@@ -425,7 +418,7 @@ mod test {
                 let proxy_balance = TicketTable::get_balance(
                     &mut host,
                     &mut tx,
-                    &NewAddress::SmartFunction(proxy),
+                    &Address::SmartFunction(proxy),
                     &ticket_hash,
                 )
                 .unwrap();
diff --git a/crates/jstz_proto/src/executor/fa_withdraw.rs b/crates/jstz_proto/src/executor/fa_withdraw.rs
index cabd2714e..a19952e30 100644
--- a/crates/jstz_proto/src/executor/fa_withdraw.rs
+++ b/crates/jstz_proto/src/executor/fa_withdraw.rs
@@ -19,7 +19,7 @@ use utoipa::ToSchema;
 
 use crate::{
     context::{
-        new_account::{Addressable, Amount, NewAddress},
+        account::{Address, Addressable, Amount},
         ticket_table::TicketTable,
     },
     Error, Result,
@@ -36,7 +36,7 @@ pub struct FaWithdraw {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RoutingInfo {
-    pub receiver: NewAddress,
+    pub receiver: Address,
     pub proxy_l1_contract: ContractKt1Hash,
 }
 
@@ -84,7 +84,7 @@ type OutboxMessageId = String;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, ToSchema, Encode, Decode)]
 pub struct FaWithdrawReceipt {
-    pub source: NewAddress,
+    pub source: Address,
     pub outbox_message_id: OutboxMessageId,
 }
 
@@ -209,7 +209,7 @@ mod test {
             ticketer: jstz_mock::kt1_account1(),
         };
         let routing_info = RoutingInfo {
-            receiver: NewAddress::User(jstz_mock::account2()),
+            receiver: Address::User(jstz_mock::account2()),
             proxy_l1_contract: jstz_mock::kt1_account1(),
         };
         FaWithdraw {
@@ -223,7 +223,7 @@ mod test {
     fn execute_fa_withdraw_succeeds() {
         let mut rt = MockHost::default();
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let fa_withdrawal = create_fa_withdrawal();
         let FaWithdraw {
             amount,
@@ -291,7 +291,7 @@ mod test {
     fn execute_fa_withdraw_fails_on_insufficient_funds() {
         let mut rt = MockHost::default();
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let fa_withdrawal = create_fa_withdrawal();
 
         tx.begin();
@@ -318,14 +318,14 @@ mod test {
     fn execute_fa_withdraw_fails_on_zero_amount() {
         let mut rt = MockHost::default();
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let ticket_info = TicketInfo {
             id: 1234,
             content: Some(b"random ticket content".to_vec()),
             ticketer: jstz_mock::kt1_account1(),
         };
         let routing_info = RoutingInfo {
-            receiver: NewAddress::User(jstz_mock::account2()),
+            receiver: Address::User(jstz_mock::account2()),
             proxy_l1_contract: jstz_mock::kt1_account1(),
         };
         let fa_withdrawal = FaWithdraw {
diff --git a/crates/jstz_proto/src/executor/mod.rs b/crates/jstz_proto/src/executor/mod.rs
index 94633c451..830cb11a1 100644
--- a/crates/jstz_proto/src/executor/mod.rs
+++ b/crates/jstz_proto/src/executor/mod.rs
@@ -2,7 +2,6 @@ use jstz_core::{host::HostRuntime, kv::Transaction};
 use tezos_crypto_rs::hash::ContractKt1Hash;
 
 use crate::{
-    context::new_account::NewAddress,
     operation::{self, ExternalOperation, Operation, SignedOperation},
     receipt::{self, Receipt},
     Result,
@@ -32,12 +31,7 @@ fn execute_operation_inner(
             content: operation::Content::DeployFunction(deployment),
             ..
         } => {
-            let result = smart_function::deploy::execute(
-                hrt,
-                tx,
-                &NewAddress::User(source.clone()),
-                deployment,
-            )?;
+            let result = smart_function::deploy::execute(hrt, tx, &source, deployment)?;
 
             Ok(receipt::ReceiptContent::DeployFunction(result))
         }
@@ -48,20 +42,10 @@ fn execute_operation_inner(
             ..
         } => {
             let result = match run.uri.host() {
-                Some(JSTZ_HOST) => smart_function::jstz_run::execute(
-                    hrt,
-                    tx,
-                    ticketer,
-                    &NewAddress::User(source.clone()),
-                    run,
-                )?,
-                _ => smart_function::run::execute(
-                    hrt,
-                    tx,
-                    &NewAddress::User(source.clone()),
-                    run,
-                    operation_hash,
-                )?,
+                Some(JSTZ_HOST) => {
+                    smart_function::jstz_run::execute(hrt, tx, ticketer, &source, run)?
+                }
+                _ => smart_function::run::execute(hrt, tx, &source, run, operation_hash)?,
             };
             Ok(receipt::ReceiptContent::RunFunction(result))
         }
diff --git a/crates/jstz_proto/src/executor/smart_function.rs b/crates/jstz_proto/src/executor/smart_function.rs
index 13a370787..0bc8c3a32 100644
--- a/crates/jstz_proto/src/executor/smart_function.rs
+++ b/crates/jstz_proto/src/executor/smart_function.rs
@@ -26,7 +26,7 @@ use tezos_smart_rollup::prelude::debug_msg;
 
 use crate::{
     api::{self, TraceData},
-    context::new_account::{Account, Addressable, Amount, NewAddress, ParsedCode},
+    context::account::{Account, Addressable, Amount, ParsedCode},
     js_logger::JsonLogger,
     operation::{OperationHash, RunFunction},
     receipt,
@@ -36,14 +36,14 @@ use crate::{
 
 pub mod headers {
 
-    use crate::context::new_account::Addressable;
+    use crate::context::account::Addressable;
 
     use super::*;
     pub const REFERRER: &str = "Referer";
 
     pub fn test_and_set_referrer(
         request: &Request,
-        referer: &NewAddress,
+        referrer: &impl Addressable,
     ) -> JsResult<()> {
         if request.headers().deref().contains_key(REFERRER) {
             return Err(JsError::from_native(
@@ -54,7 +54,7 @@ pub mod headers {
         request
             .headers()
             .deref_mut()
-            .set(REFERRER, &referer.to_base58())
+            .set(REFERRER, &referrer.to_base58())
     }
 }
 
@@ -452,7 +452,7 @@ pub mod run {
     pub fn execute(
         hrt: &mut impl HostRuntime,
         tx: &mut Transaction,
-        source: &NewAddress,
+        source: &impl Addressable,
         run: operation::RunFunction,
         operation_hash: OperationHash,
     ) -> Result<receipt::RunFunctionReceipt> {
@@ -629,7 +629,7 @@ pub mod jstz_run {
         use tezos_smart_rollup_mock::MockHost;
 
         use crate::{
-            context::ticket_table::TicketTable,
+            context::{account::Address, ticket_table::TicketTable},
             executor::{
                 fa_withdraw::{FaWithdraw, RoutingInfo, TicketInfo},
                 smart_function::jstz_run::{execute_without_ticketer, Account},
@@ -638,7 +638,7 @@ pub mod jstz_run {
             Error,
         };
 
-        use super::{execute, NewAddress};
+        use super::execute;
 
         fn withdraw_request() -> RunFunction {
             RunFunction {
@@ -668,7 +668,7 @@ pub mod jstz_run {
                 ticketer: jstz_mock::kt1_account1(),
             };
             let routing_info = RoutingInfo {
-                receiver: NewAddress::User(jstz_mock::account2()),
+                receiver: Address::User(jstz_mock::account2()),
                 proxy_l1_contract: jstz_mock::kt1_account1(),
             };
             let fa_withdrawal = FaWithdraw {
@@ -693,7 +693,7 @@ pub mod jstz_run {
         fn execute_fails_on_invalid_host() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let req = RunFunction {
                 uri: Uri::try_from("tezos://example.com/withdraw").unwrap(),
                 ..withdraw_request()
@@ -709,7 +709,7 @@ pub mod jstz_run {
         fn execute_fails_on_unsupported_path() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let req = RunFunction {
                 uri: Uri::try_from("tezos://jstz/blahblah").unwrap(),
                 ..withdraw_request()
@@ -725,7 +725,7 @@ pub mod jstz_run {
         fn execute_wthdraw_fails_on_invalid_request_method() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let req = RunFunction {
                 method: Method::GET,
                 ..withdraw_request()
@@ -744,7 +744,7 @@ pub mod jstz_run {
         fn execute_wthdraw_fails_on_invalid_request_body() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let req = RunFunction {
                 body: Some(
                     json!({
@@ -775,7 +775,7 @@ pub mod jstz_run {
         fn execute_withdraw_succeeds() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
 
             tx.begin();
             Account::add_balance(&host, &mut tx, &source, 10).unwrap();
@@ -800,7 +800,7 @@ pub mod jstz_run {
         fn execute_without_ticketer_succeeds() {
             let mut host = JstzMockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let rt = host.rt();
 
             tx.begin();
@@ -823,7 +823,7 @@ pub mod jstz_run {
         fn execute_fa_withdraw_fails_on_invalid_request_method() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let req = RunFunction {
                 method: Method::GET,
                 ..fa_withdraw_request()
@@ -842,7 +842,7 @@ pub mod jstz_run {
         fn execute_fa_withdraw_fails_on_invalid_request_body() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let req = RunFunction {
                 body: Some(
                     json!({
@@ -873,7 +873,7 @@ pub mod jstz_run {
         fn execute_fa_withdraw_succeeds() {
             let mut host = MockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
 
             let ticket = TicketInfo {
                 id: 1234,
@@ -911,7 +911,7 @@ pub mod deploy {
     pub fn execute(
         hrt: &impl HostRuntime,
         tx: &mut Transaction,
-        source: &NewAddress,
+        source: &impl Addressable,
         deployment: operation::DeployFunction,
     ) -> Result<receipt::DeployFunctionReceipt> {
         let operation::DeployFunction {
@@ -926,6 +926,8 @@ pub mod deploy {
 
     #[cfg(test)]
     mod test {
+        use crate::context::account::Address;
+
         use super::*;
         use jstz_core::kv::Transaction;
         use jstz_mock::host::JstzMockHost;
@@ -935,7 +937,7 @@ pub mod deploy {
         fn execute_deploy_deploys_smart_function_with_kt1_account1() {
             let mut host = JstzMockHost::default();
             let mut tx = Transaction::default();
-            let source = NewAddress::User(jstz_mock::account1());
+            let source = Address::User(jstz_mock::account1());
             let hrt = host.rt();
             tx.begin();
 
diff --git a/crates/jstz_proto/src/executor/withdraw.rs b/crates/jstz_proto/src/executor/withdraw.rs
index 5830cdfa5..880d21c79 100644
--- a/crates/jstz_proto/src/executor/withdraw.rs
+++ b/crates/jstz_proto/src/executor/withdraw.rs
@@ -11,7 +11,7 @@ use tezos_smart_rollup::{
 use tezos_crypto_rs::hash::ContractKt1Hash;
 
 use crate::{
-    context::new_account::{Account, Addressable, Amount, NewAddress},
+    context::account::{Account, Address, Addressable, Amount},
     Error, Result,
 };
 
@@ -20,12 +20,12 @@ const BURN_ENTRYPOINT: &str = "burn";
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Withdrawal {
     pub amount: Amount,
-    pub receiver: NewAddress,
+    pub receiver: Address,
 }
 
 fn create_withdrawal(
     amount: Amount,
-    receiver: &NewAddress,
+    receiver: &Address,
     ticketer: &ContractKt1Hash,
 ) -> Result<OutboxMessage> {
     let receiver_pkh = receiver.to_base58();
@@ -89,7 +89,7 @@ mod test {
     use tezos_smart_rollup_mock::MockHost;
 
     use crate::{
-        context::{new_account::Account, new_account::NewAddress},
+        context::{account::Account, account::Address},
         executor::withdraw::execute_withdraw,
         Error,
     };
@@ -100,10 +100,10 @@ mod test {
     fn execute_withdraw_fails_on_insufficient_funds() {
         let mut host = MockHost::default();
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let withdrawal = Withdrawal {
             amount: 11,
-            receiver: NewAddress::User(jstz_mock::account2()),
+            receiver: Address::User(jstz_mock::account2()),
         };
         let ticketer =
             ContractKt1Hash::from_base58_check(jstz_mock::host::NATIVE_TICKETER).unwrap();
@@ -125,10 +125,10 @@ mod test {
     fn execute_withdraw_succeeds() {
         let mut host = MockHost::default();
         let mut tx = Transaction::default();
-        let source = NewAddress::User(jstz_mock::account1());
+        let source = Address::User(jstz_mock::account1());
         let withdrawal = Withdrawal {
             amount: 10,
-            receiver: NewAddress::User(jstz_mock::account2()),
+            receiver: Address::User(jstz_mock::account2()),
         };
         let ticketer =
             ContractKt1Hash::from_base58_check(jstz_mock::host::NATIVE_TICKETER).unwrap();
diff --git a/crates/jstz_proto/src/operation.rs b/crates/jstz_proto/src/operation.rs
index 66b67ac91..ff43a9a4c 100644
--- a/crates/jstz_proto/src/operation.rs
+++ b/crates/jstz_proto/src/operation.rs
@@ -1,5 +1,5 @@
 use crate::{
-    context::new_account::{Account, Amount, NewAddress, Nonce, ParsedCode},
+    context::account::{Account, Address, Amount, Nonce, ParsedCode},
     Error, Result,
 };
 use bincode::{Decode, Encode};
@@ -175,7 +175,7 @@ pub mod external {
         // Amount to deposit
         pub amount: Amount,
         // Receiver address
-        pub receiver: NewAddress,
+        pub receiver: Address,
     }
 
     #[derive(Debug, PartialEq, Eq)]
@@ -186,9 +186,9 @@ pub mod external {
         // Amount to deposit
         pub amount: Amount,
         // Final deposit receiver address
-        pub receiver: NewAddress,
+        pub receiver: Address,
         // Optional proxy contract
-        pub proxy_smart_function: Option<NewAddress>,
+        pub proxy_smart_function: Option<Address>,
         // Ticket hash
         pub ticket_hash: TicketHash,
     }
@@ -241,7 +241,7 @@ pub mod openapi {
 #[cfg(test)]
 mod test {
     use super::{DeployFunction, RunFunction};
-    use crate::{context::new_account::ParsedCode, operation::Content};
+    use crate::{context::account::ParsedCode, operation::Content};
     use http::{HeaderMap, Method, Uri};
     use jstz_core::BinEncodable;
     use serde_json::json;
diff --git a/crates/jstz_proto/src/receipt.rs b/crates/jstz_proto/src/receipt.rs
index 8f2dae912..ac6749d09 100644
--- a/crates/jstz_proto/src/receipt.rs
+++ b/crates/jstz_proto/src/receipt.rs
@@ -1,5 +1,5 @@
 use crate::{
-    context::new_account::NewAddress,
+    context::account::Address,
     executor::{fa_deposit::FaDepositReceipt, fa_withdraw::FaWithdrawReceipt},
     operation::OperationHash,
     Result,
@@ -70,7 +70,7 @@ pub struct RunFunctionReceipt {
 
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema, Encode, Decode)]
 pub struct DepositReceipt {
-    pub account: NewAddress,
+    pub account: Address,
     pub updated_balance: u64,
 }