diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00e35a5d0..32426bd63 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@
 - [BREAKING] Increase of nonce does not require changes in account state any more (#796).
 - Added `CHANGELOG.md` warning message on CI (#799).
 - Account deltas can now be merged (#797).
+- Changed `AccountCode` procedures from merkle tree to sequential hash + added storage_offset support (#763).
 
 ## 0.4.0 (2024-07-03)
 
diff --git a/bench-tx/src/main.rs b/bench-tx/src/main.rs
index 28c8ed256..e0d3e9aea 100644
--- a/bench-tx/src/main.rs
+++ b/bench-tx/src/main.rs
@@ -90,7 +90,8 @@ pub fn benchmark_default_tx() -> Result<TransactionProgress, String> {
     let (stack_inputs, advice_inputs) = transaction.get_kernel_inputs();
     let advice_recorder: RecAdviceProvider = advice_inputs.into();
     let mut host: TransactionHost<_, ()> =
-        TransactionHost::new(transaction.account().into(), advice_recorder, None);
+        TransactionHost::new(transaction.account().into(), advice_recorder, None)
+            .map_err(|e| format!("Failed to create transaction host: {}", e))?;
 
     vm_processor::execute(
         transaction.program(),
@@ -174,7 +175,8 @@ pub fn benchmark_p2id() -> Result<TransactionProgress, String> {
     )]);
     let authenticator = Some(Rc::new(authenticator));
     let mut host =
-        TransactionHost::new(transaction.account().into(), advice_recorder, authenticator);
+        TransactionHost::new(transaction.account().into(), advice_recorder, authenticator)
+            .map_err(|e| format!("Failed to create transaction host: {}", e))?;
 
     vm_processor::execute(
         transaction.program(),
diff --git a/docs/architecture/transactions/procedures.md b/docs/architecture/transactions/procedures.md
index bde62bf0c..87f807e9c 100644
--- a/docs/architecture/transactions/procedures.md
+++ b/docs/architecture/transactions/procedures.md
@@ -8,73 +8,70 @@ There are user-facing procedures and kernel procedures. Users don't directly inv
 
 These procedures can be used to create smart contract/account code, note scripts, or account scripts. They basically serve as an API for the underlying kernel procedures. If a procedure can be called in the current context, an `exec` is sufficient. Otherwise the context procedures must be invoked by `call`. Users never need to invoke `syscall` procedures themselves.
 
-!!! tip
-    - If capitalized, a variable representing a `word`, e.g., `ACCT_HASH` consists of four `felts`. If lowercase, the variable is represented by a single `felt`.
+!!! tip - If capitalized, a variable representing a `word`, e.g., `ACCT_HASH` consists of four `felts`. If lowercase, the variable is represented by a single `felt`.
 
 ### Account
 
-To import the account procedures, set `use.miden::account` at the beginning of the file. 
+To import the account procedures, set `use.miden::account` at the beginning of the file.
 
 Any procedure that changes the account state must be invoked in the account context and not by note or transaction scripts. All procedures invoke `syscall` to the kernel API and some are restricted by the kernel procedure `exec.authenticate_account_origin`, which fails if the parent context is not the executing account.
 
-| Procedure name            | Stack      | Output       | Context | Description                                                         |
-|---------------------------|------------|--------------|---------|---------------------------------------------------------------------|
-| `get_id`                  | `[]`       | `[acct_id]`  | account, note | <ul> <li>Returns the account id.</li> </ul> |
-| `get_nonce`               | `[]`       | `[nonce]`    | account, note | <ul> <li>Returns the account nonce.</li> </ul> |
-| `get_initial_hash`        | `[]`       | `[H]`        | account, note | <ul> <li>Returns the initial account hash.</li> </ul> |
-| `get_current_hash`        | `[]`       | `[ACCT_HASH]`| account, note | <ul> <li>Computes and returns the account hash from account data stored in memory.</li> </ul>
-| `incr_nonce`              | `[value]`  | `[]`         | account | <ul> <li>Increments the account nonce by the provided `value` which can be at most `2^32 - 1` otherwise the procedure panics.</li> </ul> |
-| `get_item`                | `[index]`  | `[VALUE]`    | account, note | <ul> <li>Gets an item `VALUE` by `index` from the account storage. </li><li>Panics if the index is out of bounds.</li> </ul> |
-| `set_item`                | `[index, V']` | `[R', V]` | account | <ul> <li>Sets an index/value pair in the account storage. </li><li> Panics if the index is out of bounds. `R` is the new storage root.</li> </ul> |
-| `set_code`                | `[CODE_ROOT]`| `[]`       | account | <ul> <li>Sets the code (`CODE_ROOT`) of the account the transaction is being executed against. </li><li>This procedure can only be executed on regular accounts with updatable code. Otherwise, the procedure fails.</li> </ul>  |
-| `get_balance`             | `[faucet_id]`| `[balance]`| account, note | <ul> <li>Returns the `balance` of a fungible asset associated with a `faucet_id`.</li><li> Panics if the asset is not a fungible asset.</li> </ul> |
-| `has_non_fungible_asset`  | `[ASSET]`   | `[has_asset]`| account, note | <ul> <li>Returns a boolean `has_asset` indicating whether the non-fungible asset is present in the vault. </li><li> Panics if the `ASSET` is a fungible asset. </li> </ul> |
-| `add_asset`               | `[ASSET]`   | `[ASSET']`  | account | <ul> <li>Adds the specified asset `ASSET` to the vault. Panics under various conditions.</li><li> If `ASSET` is a non-fungible asset, then `ASSET'` is the same as `ASSET`.</li><li> If `ASSET` is a fungible asset, then `ASSET'` is the total fungible asset in the account vault after `ASSET` was added to it.</li> </ul> |
-| `remove_asset`            | `[ASSET]`   | `[ASSET]`   | account | <ul> <li>Removes the specified `ASSET` from the vault. </li><li>Panics under various conditions. </li> </ul> |
-| `get_vault_commitment`    | `[]`        | `[COM]`     | account, note | <ul> <li>Returns a commitment `COM` to the account vault. </li> </ul> |
+| Procedure name           | Stack               | Output        | Context       | Description                                                                                                                                                                                                                                                                                                                   |
+| ------------------------ | ------------------- | ------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `get_id`                 | `[]`                | `[acct_id]`   | account, note | <ul> <li>Returns the account id.</li> </ul>                                                                                                                                                                                                                                                                                   |
+| `get_nonce`              | `[]`                | `[nonce]`     | account, note | <ul> <li>Returns the account nonce.</li> </ul>                                                                                                                                                                                                                                                                                |
+| `get_initial_hash`       | `[]`                | `[H]`         | account, note | <ul> <li>Returns the initial account hash.</li> </ul>                                                                                                                                                                                                                                                                         |
+| `get_current_hash`       | `[]`                | `[ACCT_HASH]` | account, note | <ul> <li>Computes and returns the account hash from account data stored in memory.</li> </ul>                                                                                                                                                                                                                                 |
+| `incr_nonce`             | `[value]`           | `[]`          | account       | <ul> <li>Increments the account nonce by the provided `value` which can be at most `2^32 - 1` otherwise the procedure panics.</li> </ul>                                                                                                                                                                                      |
+| `get_item`               | `[index]`           | `[VALUE]`     | account, note | <ul> <li>Gets an item `VALUE` by `index` from the account storage. </li><li>Panics if the index is out of bounds.</li> </ul>                                                                                                                                                                                                  |
+| `set_item`               | `[index, V']`       | `[R', V]`     | account       | <ul> <li>Sets an index/value pair in the account storage. </li><li> Panics if the index is out of bounds. `R` is the new storage root.</li> </ul>                                                                                                                                                                             |
+| `set_code`               | `[CODE_COMMITMENT]` | `[]`          | account       | <ul> <li>Sets the code (`CODE_COMMITMENT`) of the account the transaction is being executed against. </li><li>This procedure can only be executed on regular accounts with updatable code. Otherwise, the procedure fails.</li> </ul>                                                                                         |
+| `get_balance`            | `[faucet_id]`       | `[balance]`   | account, note | <ul> <li>Returns the `balance` of a fungible asset associated with a `faucet_id`.</li><li> Panics if the asset is not a fungible asset.</li> </ul>                                                                                                                                                                            |
+| `has_non_fungible_asset` | `[ASSET]`           | `[has_asset]` | account, note | <ul> <li>Returns a boolean `has_asset` indicating whether the non-fungible asset is present in the vault. </li><li> Panics if the `ASSET` is a fungible asset. </li> </ul>                                                                                                                                                    |
+| `add_asset`              | `[ASSET]`           | `[ASSET']`    | account       | <ul> <li>Adds the specified asset `ASSET` to the vault. Panics under various conditions.</li><li> If `ASSET` is a non-fungible asset, then `ASSET'` is the same as `ASSET`.</li><li> If `ASSET` is a fungible asset, then `ASSET'` is the total fungible asset in the account vault after `ASSET` was added to it.</li> </ul> |
+| `remove_asset`           | `[ASSET]`           | `[ASSET]`     | account       | <ul> <li>Removes the specified `ASSET` from the vault. </li><li>Panics under various conditions. </li> </ul>                                                                                                                                                                                                                  |
+| `get_vault_commitment`   | `[]`                | `[COM]`       | account, note | <ul> <li>Returns a commitment `COM` to the account vault. </li> </ul>                                                                                                                                                                                                                                                         |
 
 ### Note
 
 To import the note procedures, set `use.miden::note` at the beginning of the file. All procedures are restricted to the note context.
 
-| Procedure name           | Inputs              | Outputs               | Context | Description                                                                                                                         |
-|--------------------------|---------------------|-----------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------|
-| `get_assets`             | `[dest_ptr]`        | `[num_assets, dest_ptr]` | note | <ul> <li>Writes the assets of the currently executing note into memory starting at the specified address `dest_ptr `. </li><li> `num_assets` is the number of assets in the currently executing note.</li> </ul>  |
-| `get_inputs`             | `[dest_ptr]`        | `[dest_ptr]`            | note | <ul> <li>Writes the inputs of the currently executed note into memory starting at the specified address, `dest_ptr`. </li> </ul> |
-| `get_sender`             | `[]`                | `[sender]`             | note | <ul> <li>Returns the `sender` of the note currently being processed. Panics if a note is not being processed. </li> </ul>  |
-| `compute_inputs_hash`    | `[inputs_ptr, num_inputs]` | `[HASH]`        | note | <ul> <li>Computes hash of note inputs starting at the specified memory address.</li> </ul> |
-
+| Procedure name        | Inputs                     | Outputs                  | Context | Description                                                                                                                                                                                                      |
+| --------------------- | -------------------------- | ------------------------ | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `get_assets`          | `[dest_ptr]`               | `[num_assets, dest_ptr]` | note    | <ul> <li>Writes the assets of the currently executing note into memory starting at the specified address `dest_ptr `. </li><li> `num_assets` is the number of assets in the currently executing note.</li> </ul> |
+| `get_inputs`          | `[dest_ptr]`               | `[dest_ptr]`             | note    | <ul> <li>Writes the inputs of the currently executed note into memory starting at the specified address, `dest_ptr`. </li> </ul>                                                                                 |
+| `get_sender`          | `[]`                       | `[sender]`               | note    | <ul> <li>Returns the `sender` of the note currently being processed. Panics if a note is not being processed. </li> </ul>                                                                                        |
+| `compute_inputs_hash` | `[inputs_ptr, num_inputs]` | `[HASH]`                 | note    | <ul> <li>Computes hash of note inputs starting at the specified memory address.</li> </ul>                                                                                                                       |
 
 ### Tx
-To import the transaction procedures set `use.miden::tx` at the beginning of the file. Only the `create_note` procedure is restricted to the account context.
 
-| Procedure name           | Inputs           | Outputs     | Context | Description                                                                                                                                                                  |
-|--------------------------|------------------|-------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `get_block_number`       | `[]`             | `[num]`     | account, note | <ul> <li>Returns the block number `num` of the last known block at the time of transaction execution. |
-| `get_block_hash`         | `[]`             | `[H]`       | account, note | <ul> <li>Returns the block hash `H` of the last known block at the time of transaction execution.</li> </ul> |
-| `get_input_notes_hash`   | `[]`             | `[COM]`     | account, note | <ul> <li>Returns the input notes hash `COM`. </li><li>This is computed as a sequential hash of (nullifier, empty_word_or_note_hash) tuples over all input notes. The `empty_word_or_notes_hash` functions as a flag, if the value is set to zero, then the notes are authenticated by the transaction kernel. If the value is non-zero, then note authentication will be delayed to the batch/block kernel. The delayed authentication allows a transaction to consume a public note that is not yet included to a block. </li> </ul> |
-| `get_output_notes_hash`  | `[0, 0, 0, 0]`   | `[COM]`     | account, note | <ul> <li>Returns the output notes hash `COM`. </li><li>This is computed as a sequential hash of (note_id, note_metadata) tuples over all output notes. </li> </ul> |
-| `create_note`            | `[ASSET, tag, RECIPIENT]` | `[ptr]` | account | <ul> <li>Creates a new note and returns a pointer to the memory address at which the note is stored.</li><li> `ASSET` is the asset to be included in the note. </li><li>`tag` is the tag to be included in the note. `RECIPIENT` is the recipient of the note.</li><li> `ptr` is the pointer to the memory address at which the note is stored.</li> </ul> |
+To import the transaction procedures set `use.miden::tx` at the beginning of the file. Only the `create_note` procedure is restricted to the account context.
 
+| Procedure name          | Inputs                    | Outputs | Context       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ----------------------- | ------------------------- | ------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `get_block_number`      | `[]`                      | `[num]` | account, note | <ul> <li>Returns the block number `num` of the last known block at the time of transaction execution.                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `get_block_hash`        | `[]`                      | `[H]`   | account, note | <ul> <li>Returns the block hash `H` of the last known block at the time of transaction execution.</li> </ul>                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `get_input_notes_hash`  | `[]`                      | `[COM]` | account, note | <ul> <li>Returns the input notes hash `COM`. </li><li>This is computed as a sequential hash of (nullifier, empty_word_or_note_hash) tuples over all input notes. The `empty_word_or_notes_hash` functions as a flag, if the value is set to zero, then the notes are authenticated by the transaction kernel. If the value is non-zero, then note authentication will be delayed to the batch/block kernel. The delayed authentication allows a transaction to consume a public note that is not yet included to a block. </li> </ul> |
+| `get_output_notes_hash` | `[0, 0, 0, 0]`            | `[COM]` | account, note | <ul> <li>Returns the output notes hash `COM`. </li><li>This is computed as a sequential hash of (note_id, note_metadata) tuples over all output notes. </li> </ul>                                                                                                                                                                                                                                                                                                                                                                    |
+| `create_note`           | `[ASSET, tag, RECIPIENT]` | `[ptr]` | account       | <ul> <li>Creates a new note and returns a pointer to the memory address at which the note is stored.</li><li> `ASSET` is the asset to be included in the note. </li><li>`tag` is the tag to be included in the note. `RECIPIENT` is the recipient of the note.</li><li> `ptr` is the pointer to the memory address at which the note is stored.</li> </ul>                                                                                                                                                                            |
 
 ### Asset
+
 To import the asset procedures set `use.miden::asset` at the beginning of the file. These procedures can only be called by faucet accounts.
 
-| Procedure name               | Stack               | Output    | Context | Description                                                                                                                                                 |
-|------------------------------|---------------------|-----------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `build_fungible_asset`       | `[faucet_id, amount]` | `[ASSET]` | faucet | <ul> <li> Builds a fungible asset `ASSET` for the specified fungible faucet `faucet_id`, and `amount` of asset to create.</li> </ul> |
-| `create_fungible_asset`      | `[amount]`          | `[ASSET]` | faucet | <ul> <li> Creates a fungible asset `ASSET` for the faucet the transaction is being executed against and `amount` of the asset to create. </li> </ul> |
-| `build_non_fungible_asset`   | `[faucet_id, DATA_HASH]` | `[ASSET]` | faucet | <ul> <li> Builds a non-fungible asset `ASSET` for the specified non-fungible faucet. </li><li> `faucet_id` is the faucet to create the asset for. </li><li> `DATA_HASH` is the data hash of the non-fungible asset to build.</li> </ul> |
-| `create_non_fungible_asset`  | `[DATA_HASH]`        | `[ASSET]` | faucet | <ul> <li> Creates a non-fungible asset `ASSET` for the faucet the transaction is being executed against. </li><li>`DATA_HASH` is the data hash of the non-fungible asset to create. </li> </ul> |
+| Procedure name              | Stack                    | Output    | Context | Description                                                                                                                                                                                                                             |
+| --------------------------- | ------------------------ | --------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `build_fungible_asset`      | `[faucet_id, amount]`    | `[ASSET]` | faucet  | <ul> <li> Builds a fungible asset `ASSET` for the specified fungible faucet `faucet_id`, and `amount` of asset to create.</li> </ul>                                                                                                    |
+| `create_fungible_asset`     | `[amount]`               | `[ASSET]` | faucet  | <ul> <li> Creates a fungible asset `ASSET` for the faucet the transaction is being executed against and `amount` of the asset to create. </li> </ul>                                                                                    |
+| `build_non_fungible_asset`  | `[faucet_id, DATA_HASH]` | `[ASSET]` | faucet  | <ul> <li> Builds a non-fungible asset `ASSET` for the specified non-fungible faucet. </li><li> `faucet_id` is the faucet to create the asset for. </li><li> `DATA_HASH` is the data hash of the non-fungible asset to build.</li> </ul> |
+| `create_non_fungible_asset` | `[DATA_HASH]`            | `[ASSET]` | faucet  | <ul> <li> Creates a non-fungible asset `ASSET` for the faucet the transaction is being executed against. </li><li>`DATA_HASH` is the data hash of the non-fungible asset to create. </li> </ul>                                         |
 
 ### Faucet
 
 To import the faucet procedures, set `use.miden::faucet` at the beginning of the file.
 
-| Procedure name           | Stack      | Outputs           | Context | Description                 |
-|--------------------------|------------|-------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `mint`                   | `[ASSET]`  | `[ASSET]`         | faucet | <ul> <li> Mint an asset `ASSET` from the faucet the transaction is being executed against. </li><li>Panics under various conditions. </li> </ul> |
-| `burn`                   | `[ASSET]`  | `[ASSET]`         | faucet | <ul> <li> Burn an asset `ASSET` from the faucet the transaction is being executed against. </li><li>Panics under various conditions. </li> </ul> |
-| `get_total_issuance`     | `[]`       | `[total_issuance]`| faucet | <ul> <li> Returns the `total_issuance` of the fungible faucet the transaction is being executed against. </li><li>Panics if the transaction is not being executed against a fungible faucet.</li> </ul> |
-
-
+| Procedure name       | Stack     | Outputs            | Context | Description                                                                                                                                                                                             |
+| -------------------- | --------- | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mint`               | `[ASSET]` | `[ASSET]`          | faucet  | <ul> <li> Mint an asset `ASSET` from the faucet the transaction is being executed against. </li><li>Panics under various conditions. </li> </ul>                                                        |
+| `burn`               | `[ASSET]` | `[ASSET]`          | faucet  | <ul> <li> Burn an asset `ASSET` from the faucet the transaction is being executed against. </li><li>Panics under various conditions. </li> </ul>                                                        |
+| `get_total_issuance` | `[]`      | `[total_issuance]` | faucet  | <ul> <li> Returns the `total_issuance` of the fungible faucet the transaction is being executed against. </li><li>Panics if the transaction is not being executed against a fungible faucet.</li> </ul> |
diff --git a/miden-lib/asm/kernels/transaction/api.masm b/miden-lib/asm/kernels/transaction/api.masm
index ad69fab4e..f62d5844b 100644
--- a/miden-lib/asm/kernels/transaction/api.masm
+++ b/miden-lib/asm/kernels/transaction/api.masm
@@ -50,10 +50,11 @@ proc.authenticate_account_origin
 
     # assert that the caller is from the user context
     exec.account::authenticate_procedure
-    # => [CALLER, ...]
+    # => [storage_offset, ...]
 
-    # drop the caller
-    dropw
+    # TODO: use the storage_offset for storage access
+    # drop the storage_offset
+    drop
     # => [...]
 end
 
@@ -260,18 +261,18 @@ end
 #! Sets the code of the account the transaction is being executed against. This procedure can only
 #! executed on regular accounts with updatable code. Otherwise, this procedure fails.
 #!
-#! Stack: [CODE_ROOT]
+#! Stack: [CODE_COMMITMENT]
 #! Output: [0, 0, 0, 0]
 #!
-#! - CODE_ROOT is the hash of the code to set.
+#! - CODE_COMMITMENT is the hash of the code to set.
 export.set_account_code
     # authenticate that the procedure invocation originates from the account context
     exec.authenticate_account_origin
-    # => [CODE_ROOT]
+    # => [CODE_COMMITMENT]
 
     # arrange stack
     padw swapw
-    # => [CODE_ROOT, 0, 0, 0, 0]
+    # => [CODE_COMMITMENT, 0, 0, 0, 0]
 
     # set the account code
     exec.account::set_code
diff --git a/miden-lib/asm/miden/account.masm b/miden-lib/asm/miden/account.masm
index 5020ef9a1..200f72c69 100644
--- a/miden-lib/asm/miden/account.masm
+++ b/miden-lib/asm/miden/account.masm
@@ -143,10 +143,10 @@ end
 #! Sets the code of the account the transaction is being executed against. This procedure can only
 #! executed on regular accounts with updatable code. Otherwise, this procedure fails.
 #!
-#! Stack: [CODE_ROOT]
+#! Stack: [CODE_COMMITMENT]
 #! Output: []
 #!
-#! - CODE_ROOT is the hash of the code to set.
+#! - CODE_COMMITMENT is the hash of the code to set.
 export.set_code
     syscall.set_account_code
     # => [0, 0, 0, 0]
diff --git a/miden-lib/asm/miden/kernels/tx/account.masm b/miden-lib/asm/miden/kernels/tx/account.masm
index 5e14d1291..814e04f41 100644
--- a/miden-lib/asm/miden/kernels/tx/account.masm
+++ b/miden-lib/asm/miden/kernels/tx/account.masm
@@ -28,6 +28,12 @@ const.ERR_SETTING_NON_VALUE_ITEM_ON_VALUE_SLOT=0x00020047
 # Setting a map item on a non-map slot
 const.ERR_SETTING_MAP_ITEM_ON_NON_MAP_SLOT=0x00020048
 
+# Account procedure is not part of the account code
+const.ERR_PROC_NOT_PART_OF_ACCOUNT_CODE=0x0002004A
+
+# Provided index is out of bounds
+const.ERR_PROC_INDEX_OUT_OF_BOUNDS=0x0002004B
+
 # CONSTANTS
 # =================================================================================================
 
@@ -69,6 +75,9 @@ const.SLOT_TYPES_COMMITMENT_STORAGE_SLOT=255
 # The maximum value a slot type can take (An array of depth 64).
 const.MAX_SLOT_TYPE=64
 
+# The maximum number of account interface procedures.
+const.MAX_NUM_PROCEDURES=65535
+
 # EVENTS
 # =================================================================================================
 
@@ -127,6 +136,16 @@ export.get_max_slot_type
     push.MAX_SLOT_TYPE
 end
 
+#! Returns the maximum number of account interface procedures.
+#!
+#! Stack: []
+#! Output: [max_num_procedures]
+#!
+#! - max_num_procedures is the maximum number of account interface procedures.
+export.get_max_num_procedures
+    push.MAX_NUM_PROCEDURES
+end
+
 # PROCEDURES
 # =================================================================================================
 
@@ -299,21 +318,21 @@ end
 #! Sets the code of the account the transaction is being executed against. This procedure can only
 #! executed on regular accounts with updatable code. Otherwise, this procedure fails.
 #!
-#! Stack: [CODE_ROOT]
+#! Stack: [CODE_COMMITMENT]
 #! Output: []
 #!
-#! - CODE_ROOT is the hash of the code to set.
+#! - CODE_COMMITMENT is the hash of the code to set.
 export.set_code
     # get the account id
     exec.memory::get_acct_id
-    # => [acct_id, CODE_ROOT]
+    # => [acct_id, CODE_COMMITMENT]
 
     # assert the account is an updatable regular account
     exec.is_updatable_account assert.err=ERR_ACCOUNT_SET_CODE_ACCOUNT_MUST_BE_UPDATABLE
-    # => [CODE_ROOT]
+    # => [CODE_COMMITMENT]
 
-    # set the code root
-    exec.memory::set_new_acct_code_root dropw
+    # set the code commitment
+    exec.memory::set_new_acct_code_commitment dropw
     # => []
 end
 
@@ -374,7 +393,7 @@ proc.set_item_raw
     # => [OLD_VALUE]
 end
 
-#! Sets an item in the account storage. Panics if 
+#! Sets an item in the account storage. Panics if
 #! - the index is out of bounds
 #! - the slot type is not value
 #!
@@ -469,39 +488,79 @@ export.set_map_item.3
     # => [OLD_MAP_ROOT, OLD_VALUE, ...]
 end
 
-#! Verifies that the procedure root is part of the account code Merkle tree. Panics if the
-#! procedure root is not part of the account code Merkle tree.
+#! Returns the procedure information
+#!
+#! Stack: [index, ...]
+#! Output: [PROC_ROOT, storage_offset, ...]
+#!
+#! - PROC_ROOT is the hash of the procedure.
+#! - storage_offset is the procedure storage offset.
+#!
+#! Panics if
+#! - index is out of bounds
+export.get_procedure_info
+  # TODO: Fix VM caller == [0,0,0,0] bug and remove this check
+  # check if index == 255
+  dup push.255 neq
+  # => [is_255, index]
+
+  # load procedure information from memory
+  if.true
+    # check that index < number of procedures contained in the account code
+    dup exec.memory::get_num_account_procedures lt assert.err=ERR_PROC_INDEX_OUT_OF_BOUNDS
+    # => [index]
+
+    # get procedure section ptr
+    push.2 mul exec.memory::get_account_procedures_section_offset add dup push.1 add
+    # => [proc_ptr, offset_ptr]
+
+    # load procedure information from memory
+    mem_load swap padw movup.4 mem_loadw
+    # => [PROC_ROOT, storage_offset]
+  end
+ end
+
+#! Verifies that the procedure root is part of the account code
 #!
 #! Stack: [PROC_ROOT]
-#! Output: [PROC_ROOT]
+#! Output: [storage_offset]
 #!
 #! - PROC_ROOT is the hash of the procedure to authenticate.
-export.authenticate_procedure.1
-    # load the account code root onto the stack
-    exec.memory::get_acct_code_root swapw
-    # => [PROC_ROOT, CODE_ROOT]
-
-    # load the index of the procedure root onto the advice stack, and move it to the operand stack
-    emit.ACCOUNT_PUSH_PROCEDURE_INDEX_EVENT adv_push.1 movdn.4
-    # => [PROC_ROOT, index, CODE_ROOT]
-
-    # push the depth of the code Merkle tree onto the stack
-    push.ACCOUNT_CODE_TREE_DEPTH movdn.4
-    # => [PROC_ROOT, depth, index, CODE_ROOT]
-
-    # verify the procedure exists in the account code Merkle tree
-    mtree_verify
-    # => [PROC_ROOT, depth, index, CODE_ROOT]
-
-    # drop accessory variables
-    movup.4 drop movup.4 drop swapw dropw
-    # => [PROC_ROOT]
+#!
+#! Panics if
+#! - procedure root is not part of the account code.
+export.authenticate_procedure
+    # load procedure index
+    emit.ACCOUNT_PUSH_PROCEDURE_INDEX_EVENT adv_push.1
+    # => [index, PROC_ROOT]
+
+    # get procedure info (PROC_ELEMENTS, storage_offset) from memory stored at index
+    exec.get_procedure_info
+    # In production:
+    # => [PROC_ELEMENTS, storage_offset, PROC_ROOT]
+    # During testing:
+    # => [255, PROC_ROOT]
+
+    # TODO: Fix VM caller == [0,0,0,0] bug and remove this check
+    # check if get_procedure_info returned 255
+    dup push.255 neq
+    # => [is_255, index, PROC_ROOT]
+
+    # verify that PROC_ROOT matches returned procedure information
+    if.true
+      # verify that PROC_ROOT exists in memory at index
+      movup.4 movdn.8 assert_eqw.err=ERR_PROC_NOT_PART_OF_ACCOUNT_CODE
+      # => [storage_offset]
+    else
+      # drop PROC_ROOT
+      movdn.4 dropw
+    end
 end
 
 #! Validates that the account seed, provided via the advice map, satisfies the seed requirements.
 #!
 #! Validation is performed via the following steps:
-#! 1. compute the hash of (SEED, CODE_ROOT, STORAGE_ROOT, 0, 0, 0, 0)
+#! 1. compute the hash of (SEED, CODE_commitment, STORAGE_ROOT, 0, 0, 0, 0)
 #! 2. Assert the least significant element of the digest is equal to the account id of the account
 #!    the transaction is being executed against.
 #! 3. Assert the most significant element has sufficient proof of work (trailing zeros) for the account
@@ -514,11 +573,11 @@ export.validate_seed
         padw exec.memory::get_acct_id push.0.0.0 adv.push_mapval adv_loadw
         # => [SEED, 0, 0, 0, 0]
 
-        # populate last four elements of the hasher rate with the code root
-        exec.memory::get_acct_code_root
-        # => [CODE_ROOT, SEED, 0, 0, 0, 0]
+        # populate last four elements of the hasher rate with the code commitment
+        exec.memory::get_acct_code_commitment
+        # => [CODE_COMMITMENT, SEED, 0, 0, 0, 0]
 
-        # perform first permutation of seed and code_root (from advice stack) perm(seed, code_root)
+        # perform first permutation of seed and code_commitment (from advice stack) perm(seed, code_commitment)
         hperm
         # => [RATE, RATE, PERM]
 
diff --git a/miden-lib/asm/miden/kernels/tx/epilogue.masm b/miden-lib/asm/miden/kernels/tx/epilogue.masm
index f41e43eab..7a4ac721a 100644
--- a/miden-lib/asm/miden/kernels/tx/epilogue.masm
+++ b/miden-lib/asm/miden/kernels/tx/epilogue.masm
@@ -144,20 +144,20 @@ end
 # ACCOUNT CODE UPDATE
 # =================================================================================================
 
-#! Updates the account code root if the account code has changed. `NEW_ACCT_CODE_ROOT` is set to
-#! the initial account code root in the prologue and as such this procedure will not result in a
-#! change to the account code root if the `account::set_code` procedure has not been invoked in
-#! this transaction.
+#! Updates the account code commitment if the account code has changed. `NEW_ACCT_CODE_COMMITMENT`
+#! is set to the initial account code commitment in the prologue and as such this procedure will
+#! not result in a change to the account code commitment if the `account::set_code` procedure has
+#! not been invoked in this transaction.
 #!
 #! Stack: []
 #! Output: []
 proc.update_account_code
-    # check if the account code root has been updated
-    exec.memory::get_new_acct_code_root
-    # => [NEW_ACCT_CODE_ROOT]
+    # check if the account code commitment has been updated
+    exec.memory::get_new_acct_code_commitment
+    # => [NEW_ACCT_CODE_COMMITMENT]
 
-    # set the account code root to the new account code root (may not have changed)
-    exec.memory::set_acct_code_root dropw
+    # set the account code commitment to the new account code commitment (may not have changed)
+    exec.memory::set_acct_code_commitment dropw
     # => []
 end
 
diff --git a/miden-lib/asm/miden/kernels/tx/memory.masm b/miden-lib/asm/miden/kernels/tx/memory.masm
index 179482171..01bcf180d 100644
--- a/miden-lib/asm/miden/kernels/tx/memory.masm
+++ b/miden-lib/asm/miden/kernels/tx/memory.masm
@@ -108,18 +108,24 @@ const.ACCT_VAULT_ROOT_PTR=401
 # The memory address at which the account storage root is stored
 const.ACCT_STORAGE_ROOT_PTR=402
 
-# The memory address at which the account code root is stored
-const.ACCT_CODE_ROOT_PTR=403
+# The memory address at which the account code commitment is stored
+const.ACCT_CODE_COMMITMENT_PTR=403
 
-# The memory address at which the new account code root is stored
-const.ACCT_NEW_CODE_ROOT_PTR=404
+# The memory address at which the new account code commitment is stored
+const.ACCT_NEW_CODE_COMMITMENT_PTR=404
 
 # The memory offset at which the account data section ends (exclusive)
 const.ACCT_CORE_DATA_SECTION_END_OFFSET=404
 
-# The memory address at which the account storage slot type data beings
+# The memory address at which the account storage slot type data begins
 const.ACCT_STORAGE_SLOT_TYPE_DATA_OFFSET=405
 
+# The memory address at which the number of procedures contained in the account code is stored
+const.NUM_ACCT_PROCEDURES_PTR=999
+
+# The memory address at which the account procedures section begins
+const.ACCT_PROCEDURES_SECTION_OFFSET=1000
+
 # INPUT NOTES DATA
 # -------------------------------------------------------------------------------------------------
 
@@ -232,7 +238,7 @@ end
 #! Where:
 #! - INPUT_VAULT_ROOT is the input vault root.
 export.set_input_vault_root
-    push.INPUT_VAULT_ROOT_PTR 
+    push.INPUT_VAULT_ROOT_PTR
     mem_storew
 end
 
@@ -266,7 +272,7 @@ end
 #! Where:
 #! - OUTPUT_VAULT_ROOT is the output vault root.
 export.set_output_vault_root
-    push.OUTPUT_VAULT_ROOT_PTR 
+    push.OUTPUT_VAULT_ROOT_PTR
     mem_storew
 end
 
@@ -282,7 +288,7 @@ end
 #! Where:
 #! - BLOCK_HASH, reference block for the transaction execution.
 export.set_block_hash
-    push.BLK_HASH_PTR 
+    push.BLK_HASH_PTR
     mem_storew
 end
 
@@ -326,7 +332,7 @@ end
 #! Where:
 #! - INIT_ACCT_HASH is the initial account hash.
 export.set_init_acct_hash
-    push.INIT_ACCT_HASH_PTR 
+    push.INIT_ACCT_HASH_PTR
     mem_storew
 end
 
@@ -362,7 +368,7 @@ end
 #! Where:
 #! - INPUT_NOTES_COMMITMENT is the notes' commitment.
 export.set_nullifier_commitment
-    push.INPUT_NOTES_COMMITMENT_PTR 
+    push.INPUT_NOTES_COMMITMENT_PTR
     mem_storew
 end
 
@@ -407,7 +413,7 @@ end
 #! Where:
 #! - TX_SCRIPT_ROOT is the transaction script root.
 export.set_tx_script_root
-    push.TX_SCRIPT_ROOT_PTR 
+    push.TX_SCRIPT_ROOT_PTR
     mem_storew
 end
 
@@ -544,7 +550,7 @@ end
 #! Where:
 #! - NOTE_ROOT is the note root of the last known block.
 export.set_note_root
-    push.NOTE_ROOT_PTR 
+    push.NOTE_ROOT_PTR
     mem_storew
 end
 
@@ -644,50 +650,83 @@ export.set_acct_nonce
     drop movup.3 push.ACCT_ID_AND_NONCE_PTR mem_storew dropw
 end
 
-#! Sets the code root of the account.
+#! Sets the number of procedures contained in the account code.
+#!
+#! Stack: [num_procedures]
+#! Output: []
+#!
+#! Where:
+#! - num_procedures is the number of procedures contained in the account code.
+export.set_num_account_procedures
+    push.NUM_ACCT_PROCEDURES_PTR mem_store
+end
+
+#! Returns the number of procedures contained in the account code.
 #!
-#! Stack: [CODE_ROOT]
-#! Output: [CODE_ROOT]
+#! Stack: []
+#! Output: [num_procedures]
 #!
 #! Where:
-#! - CODE_ROOT is the code root to be set.
-export.set_acct_code_root
-    push.ACCT_CODE_ROOT_PTR 
+#! - num_procedures is the number of procedures contained in the account code.
+export.get_num_account_procedures
+    push.NUM_ACCT_PROCEDURES_PTR mem_load
+end
+
+#! Returns the account procedures section offset.
+#!
+#! Stack: []
+#! Output: [section_offset]
+#!
+#! Where:
+#! - section_offset is the account procedures section offset.
+export.get_account_procedures_section_offset
+    push.ACCT_PROCEDURES_SECTION_OFFSET
+end
+
+#! Sets the code commitment of the account.
+#!
+#! Stack: [CODE_COMMITMENT]
+#! Output: [CODE_COMMITMENT]
+#!
+#! Where:
+#! - CODE_COMMITMENT is the code commitment to be set.
+export.set_acct_code_commitment
+    push.ACCT_CODE_COMMITMENT_PTR
     mem_storew
 end
 
-#! Returns the code root of the account.
+#! Returns the code commitment of the account.
 #!
 #! Stack: []
-#! Output: [CODE_ROOT]
+#! Output: [CODE_COMMITMENT]
 #!
 #! Where:
-#! - CODE_ROOT is the code root of the account.
-export.get_acct_code_root
-    padw push.ACCT_CODE_ROOT_PTR mem_loadw
+#! - CODE_COMMITMENT is the code commitment of the account.
+export.get_acct_code_commitment
+    padw push.ACCT_CODE_COMMITMENT_PTR mem_loadw
 end
 
-#! Stores the new account code root in memory.
+#! Stores the new account code commitment in memory.
 #!
-#! Stack: [CODE_ROOT]
-#! Output: [CODE_ROOT]
+#! Stack: [CODE_COMMITMENT]
+#! Output: [CODE_COMMITMENT]
 #!
 #! Where:
-#! - CODE_ROOT is the new account code root.
-export.set_new_acct_code_root
-    push.ACCT_NEW_CODE_ROOT_PTR 
+#! - CODE_COMMITMENT is the new account code commitment.
+export.set_new_acct_code_commitment
+    push.ACCT_NEW_CODE_COMMITMENT_PTR
     mem_storew
 end
 
-#! Returns the new account code root.
+#! Returns the new account code commitment.
 #!
 #! Stack: []
-#! Output: [CODE_ROOT]
+#! Output: [CODE_COMMITMENT]
 #!
 #! Where:
-#! - CODE_ROOT is the new account code root.
-export.get_new_acct_code_root
-    padw push.ACCT_NEW_CODE_ROOT_PTR mem_loadw
+#! - CODE_COMMITMENT is the new account code commitment.
+export.get_new_acct_code_commitment
+    padw push.ACCT_NEW_CODE_COMMITMENT_PTR mem_loadw
 end
 
 #! Returns the account storage root.
@@ -709,7 +748,7 @@ end
 #! Where:
 #! - STORAGE_ROOT is the account storage root.
 export.set_acct_storage_root
-    push.ACCT_STORAGE_ROOT_PTR 
+    push.ACCT_STORAGE_ROOT_PTR
     mem_storew
 end
 
@@ -743,7 +782,7 @@ end
 #! Where:
 #! - ACCT_VAULT_ROOT is the account vault root to be set.
 export.set_acct_vault_root
-    push.ACCT_VAULT_ROOT_PTR 
+    push.ACCT_VAULT_ROOT_PTR
     mem_storew
 end
 
@@ -1102,7 +1141,7 @@ end
 #! - recipient is the recipient of the note
 #! - note_ptr is the memory address at which the output note data begins.
 export.set_output_note_recipient
-    push.OUTPUT_NOTE_RECIPIENT_OFFSET add 
+    push.OUTPUT_NOTE_RECIPIENT_OFFSET add
     mem_storew
 end
 
@@ -1115,7 +1154,7 @@ end
 #! - METADATA is the note metadata
 #! - note_ptr is the memory address at which the output note data begins.
 export.set_output_note_metadata
-    push.OUTPUT_NOTE_METADATA_OFFSET add 
+    push.OUTPUT_NOTE_METADATA_OFFSET add
     mem_storew
 end
 
@@ -1172,6 +1211,6 @@ end
 #! - output_note_data_ptr is the memory address at which the output note data begins.
 #! - ASSET_HASH, sequential hash of the padded assets of an output note.
 export.set_output_note_assets_hash
-    push.OUTPUT_NOTE_ASSETS_HASH_OFFSET add 
+    push.OUTPUT_NOTE_ASSETS_HASH_OFFSET add
     mem_storew
 end
diff --git a/miden-lib/asm/miden/kernels/tx/prologue.masm b/miden-lib/asm/miden/kernels/tx/prologue.masm
index f1f3e0a31..dbb653267 100644
--- a/miden-lib/asm/miden/kernels/tx/prologue.masm
+++ b/miden-lib/asm/miden/kernels/tx/prologue.masm
@@ -1,6 +1,7 @@
-use.std::collections::smt
+use.std::mem
 use.std::collections::mmr
 use.std::crypto::hashes::native
+use.std::collections::smt
 
 use.miden::kernels::tx::account
 use.miden::kernels::tx::asset_vault
@@ -71,6 +72,12 @@ const.ERR_PROLOGUE_TOO_MANY_INPUT_NOTES=0x0002001E
 # Cannot compute matching nullifier commitment using the provided input note data
 const.ERR_PROLOGUE_INPUT_NOTES_COMMITMENT_MISMATCH=0x0002001F
 
+# Computed account code hash does not match recorded account code hash
+const.ERR_ACCT_CODE_HASH_MISMATCH=0x0002004C
+
+# Number of account procedures exceeded the maximum limit of 65535
+const.ERR_ACCT_TOO_MANY_PROCEDURES=0x0002004D
+
 # PUBLIC INPUTS
 # =================================================================================================
 
@@ -384,6 +391,57 @@ proc.validate_new_account
     # => []
 end
 
+#! Validates that account procedures match account code commitment and saves procedure information
+#! into memory.
+#!
+#! This is achieved by reading account procedure information from the advice map, saving it into
+#! memory, and sequentially hashing them before comparing the final hash to the account code
+#! commitment.
+#!
+#! Information for each saved procedure consists of the procedure's MAST root and the storage
+#! offset associated with this procedure.
+#!
+#! Stack: [CODE_COMMITMENT]
+#! Output: []
+proc.validate_account_procedures
+  # move procedure data from the advice map to the advice stack and then push the number of
+  # procedures onto the operand stack before storing it in memory
+  adv.push_mapval adv_push.1
+  # => [num_procs, CODE_COMMITMENT]
+
+  # assert that account does not exceed allowed maximum number of procedures
+  dup exec.account::get_max_num_procedures lt assert.err=ERR_ACCT_TOO_MANY_PROCEDURES
+  # => [num_procs, CODE_COMMITMENT]
+
+  # store number of procedures in memory
+  dup exec.memory::set_num_account_procedures
+  # => [num_procs, CODE_COMMITMENT]
+
+  # setup acct_proc_offset and end_ptr for reading from advice stack
+  mul.2 exec.memory::get_account_procedures_section_offset dup movdn.2 add swap
+  # => [acct_proc_offset, end_ptr, CODE_COMMITMENT]
+
+  # pad stack before reading from advice stack
+  padw padw padw
+  # => [PAD, PAD, PAD, acct_proc_offset, end_ptr, CODE_COMMITMENT]
+
+  # read the data from advice stack to memory and hash
+  exec.mem::pipe_double_words_to_memory
+  # => [PERM, PERM, PERM, end_ptr, CODE_COMMITMENT]
+
+  # extract the digest
+  exec.native::state_to_digest
+  # => [DIGEST, end_ptr, CODE_COMMITMENT]
+
+  # drop end_ptr
+  movup.4 drop
+  # => [DIGEST, CODE_COMMITMENT]
+
+  # verify hashed account procedures match account code commitment
+  assert_eqw.err=ERR_ACCT_CODE_HASH_MISMATCH
+  # => []
+end
+
 #! Saves the account data to memory and validates it.
 #!
 #! This procedure will:
@@ -396,7 +454,7 @@ end
 #!   and the account nonce is not zero
 #!
 #! Stack: []
-#! Advice stack: [[account_id, 0, 0, account_nonce], ACCOUNT_VAULT_ROOT, ACCOUNT_STORAGE_ROOT, ACCOUNT_CODE_ROOT]
+#! Advice stack: [[account_id, 0, 0, account_nonce], ACCOUNT_VAULT_ROOT, ACCOUNT_STORAGE_ROOT, ACCOUNT_CODE_COMMITMENT]
 #! Output: []
 #!
 #! Where:
@@ -404,7 +462,7 @@ end
 #! - account_nonce, account's nonce.
 #! - ACCOUNT_VAULT_ROOT, account's vault root.
 #! - ACCOUNT_STORAGE_ROOT, account's storage root.
-#! - ACCOUNT_CODE_ROOT, account's code root.
+#! - ACCOUNT_CODE_COMMITMENT, account's code commitment.
 proc.process_account_data
     # Copy the account data from the advice stack to memory and hash it
     # ---------------------------------------------------------------------------------------------
@@ -472,10 +530,13 @@ proc.process_account_data
     exec.memory::set_init_nonce
     # => []
 
-    # set the new account code root to the initial account code root this is used for managing
-    # code root updates
-    exec.memory::get_acct_code_root
-    exec.memory::set_new_acct_code_root dropw
+    # set the new account code commitment to the initial account code root this is used for managing
+    # code commitment updates
+    exec.memory::get_acct_code_commitment
+    exec.memory::set_new_acct_code_commitment
+
+    # validates and stores account procedures in memory.
+    exec.validate_account_procedures
     # => []
 
     # copy the initial account vault hash to the input vault hash to support transaction asset
@@ -1040,7 +1101,7 @@ end
 #!     [account_id, 0, 0, account_nonce],
 #!     ACCOUNT_VAULT_ROOT,
 #!     ACCOUNT_STORAGE_ROOT,
-#!     ACCOUNT_CODE_ROOT,
+#!     ACCOUNT_CODE_COMMITMENT,
 #!     number_of_input_notes,
 #!     TX_SCRIPT_ROOT,
 #! ]
@@ -1068,7 +1129,7 @@ end
 #! - account_nonce, account's nonce.
 #! - ACCOUNT_VAULT_ROOT, account's vault root.
 #! - ACCOUNT_STORAGE_ROOT, account's storage root.
-#! - ACCOUNT_CODE_ROOT, account's code root.
+#! - ACCOUNT_CODE_COMMITMENT, account's code commitment.
 #! - number_of_input_notes, number of input notes.
 #! - TX_SCRIPT_ROOT, the transaction's script root.
 #! - MMR_PEAKS, is the MMR peak data, see process_chain_data
diff --git a/miden-lib/asm/miden/note.masm b/miden-lib/asm/miden/note.masm
index e19f449fe..17456575f 100644
--- a/miden-lib/asm/miden/note.masm
+++ b/miden-lib/asm/miden/note.masm
@@ -147,14 +147,14 @@ end
 
 #! Computes hash of note inputs starting at the specified memory address.
 #!
-#! This procedure divides the hashing process into two parts: hashing pairs of words using 
+#! This procedure divides the hashing process into two parts: hashing pairs of words using
 #! `hash_memory_even` procedure and hashing the remaining values using the `hperm` instruction.
 #!
 #! If the number if inputs is 0, procedure returns the empty word: [0, 0, 0, 0].
 #!
 #! Inputs:  [inputs_ptr, num_inputs]
 #! Outputs: [HASH]
-#! Cycles: 
+#! Cycles:
 #! - If number of elements divides by 8: 56 cycles + 3 * words
 #! - Else: 189 cycles + 3 * words
 #!
@@ -163,7 +163,7 @@ export.compute_inputs_hash
     # check that number of inputs is less than 128
     dup.1 push.128 u32assert2 u32lte assert
 
-    # move number of inputs to the top of the stack 
+    # move number of inputs to the top of the stack
     swap
     # => [num_inputs, inputs_ptr]
 
@@ -178,9 +178,9 @@ export.compute_inputs_hash
     # get the padding flag to add it to the capacity part
     dup.2 eq.0 not
     # => [pad_flag, inputs_ptr, end_addr, num_inputs%8]
-    
-    # prepare hasher state for RPO permutation 
-    push.0.0.0 padw padw 
+
+    # prepare hasher state for RPO permutation
+    push.0.0.0 padw padw
     # => [C, B, A, inputs_ptr, end_addr, num_inputs%8]
 
     # hash every pair of words
@@ -210,7 +210,7 @@ export.compute_inputs_hash
         # => [E, D, A', drop_counter]
 
         ### 0th value ########################################################
-        
+
         # if current value is the last value to drop ("cycle" number equals to the number of values
         # to drop), push 1 instead of 0 to the stack
         dup.12 eq.1 swap
@@ -220,9 +220,9 @@ export.compute_inputs_hash
         # => [e_2, e_1, e_0, d_3, d_2, d_1, 0/1, d_0, A', drop_counter]
 
         ### 1st value ########################################################
-        
+
         # prepare the second element of the E Word for cdrop instruction
-        # if current value is the last value to drop ("cycle" number equals to the number of values 
+        # if current value is the last value to drop ("cycle" number equals to the number of values
         # to drop), push 1 instead of 0 to the stack
         dup.12 eq.2 swap
         # => [e_2, 0, e_1, e_0, d_3, d_2, d_1, 0/1, d_0, A', drop_counter]
@@ -239,7 +239,7 @@ export.compute_inputs_hash
         or
         # => [latch', e_2, 0, e_1, e_0, d_3, d_2, d_1, 0, d_0, A', drop_counter]
 
-        # save the latch value 
+        # save the latch value
         dup movdn.14
         # => [latch', e_2, 0, e_1, e_0, d_3, d_2, d_1, 0, d_0, A', latch', drop_counter]
 
@@ -247,7 +247,7 @@ export.compute_inputs_hash
         cdrop
         # => [e_2_or_0, e_1, e_0, d_3, d_2, d_1, 0, d_0, A', latch', drop_counter]
 
-        # move the calculated value down the stack 
+        # move the calculated value down the stack
         movdn.6
         # => [e_1, e_0, d_3, d_2, d_1, 0, e_2_or_0, d_0, A', latch', drop_counter]
 
@@ -296,8 +296,8 @@ export.compute_inputs_hash
         # => [0, e_2_or_0, e_1_or_0, e_0_or_0, d_3_or_0, d_2_or_0, d_1_or_0, d_0, A']
         # or in other words
         # => [C, B, A', ... ]
-        # notice that we don't need to check the d_0 value: entering the else branch means that 
-        # we have number of elements not divisible by 8, so we will have at least one element to 
+        # notice that we don't need to check the d_0 value: entering the else branch means that
+        # we have number of elements not divisible by 8, so we will have at least one element to
         # hash here (which turns out to be d_0)
 
         hperm
diff --git a/miden-lib/src/accounts/faucets/mod.rs b/miden-lib/src/accounts/faucets/mod.rs
index 3fc871a86..898a91002 100644
--- a/miden-lib/src/accounts/faucets/mod.rs
+++ b/miden-lib/src/accounts/faucets/mod.rs
@@ -79,7 +79,7 @@ pub fn create_basic_fungible_faucet(
         init_seed,
         AccountType::FungibleFaucet,
         account_storage_type,
-        account_code.root(),
+        account_code.commitment(),
         account_storage.root(),
     )?;
 
diff --git a/miden-lib/src/accounts/wallets/mod.rs b/miden-lib/src/accounts/wallets/mod.rs
index 3c3232e2c..075f4234d 100644
--- a/miden-lib/src/accounts/wallets/mod.rs
+++ b/miden-lib/src/accounts/wallets/mod.rs
@@ -67,7 +67,7 @@ pub fn create_basic_wallet(
         init_seed,
         account_type,
         account_storage_type,
-        account_code.root(),
+        account_code.commitment(),
         account_storage.root(),
     )?;
 
diff --git a/miden-lib/src/transaction/inputs.rs b/miden-lib/src/transaction/inputs.rs
index 1fd6eb51e..59be5709f 100644
--- a/miden-lib/src/transaction/inputs.rs
+++ b/miden-lib/src/transaction/inputs.rs
@@ -1,7 +1,7 @@
 use alloc::vec::Vec;
 
 use miden_objects::{
-    accounts::Account,
+    accounts::{Account, AccountProcedureInfo},
     transaction::{
         ChainMmr, ExecutedTransaction, InputNote, InputNotes, PreparedTransaction, TransactionArgs,
         TransactionInputs, TransactionScript, TransactionWitness,
@@ -116,7 +116,7 @@ fn extend_advice_inputs(
 ///     [account_id, 0, 0, account_nonce],
 ///     ACCOUNT_VAULT_ROOT,
 ///     ACCOUNT_STORAGE_ROOT,
-///     ACCOUNT_CODE_ROOT,
+///     ACCOUNT_CODE_COMMITMENT,
 ///     number_of_input_notes,
 ///     TX_SCRIPT_ROOT,
 /// ]
@@ -149,7 +149,7 @@ fn build_advice_stack(
     inputs.extend_stack([account.id().into(), ZERO, ZERO, account.nonce()]);
     inputs.extend_stack(account.vault().commitment());
     inputs.extend_stack(account.storage().root());
-    inputs.extend_stack(account.code().root());
+    inputs.extend_stack(account.code().commitment());
 
     // push the number of input notes onto the stack
     inputs.extend_stack([Felt::from(tx_inputs.input_notes().num_notes() as u32)]);
@@ -195,12 +195,11 @@ fn add_chain_mmr_to_advice_inputs(mmr: &ChainMmr, inputs: &mut AdviceInputs) {
 /// Inserts the following items into the Merkle store:
 /// - The Merkle nodes associated with the storage slots tree.
 /// - The Merkle nodes associated with the account vault tree.
-/// - The Merkle nodes associated with the account code procedures tree.
 /// - If present, the Merkle nodes associated with the account storage maps.
 ///
 /// Inserts the following entries into the advice map:
 /// - The storage types commitment |-> storage slot types vector.
-/// - The account procedure root |-> procedure index, for each account procedure.
+/// - The account code commitment |-> procedures as elements and length.
 /// - The node |-> (key, value), for all leaf nodes of the asset vault SMT.
 /// - [account_id, 0, 0, 0] |-> account_seed, when account seed is provided.
 /// - If present, the Merkle leaves associated with the account storage maps.
@@ -245,8 +244,11 @@ fn add_account_to_advice_inputs(
     // --- account code -------------------------------------------------------
     let code = account.code();
 
-    // extend the merkle store with account code tree
-    inputs.extend_merkle_store(code.procedure_tree().inner_nodes());
+    // extend the advice_map with the account code data and number of procedures
+    let num_procs = code.as_elements().len() / AccountProcedureInfo::NUM_ELEMENTS_PER_PROC;
+    let mut procs = code.as_elements();
+    procs.insert(0, Felt::from(num_procs as u32));
+    inputs.extend_map([(code.commitment(), procs)]);
 
     // --- account seed -------------------------------------------------------
     if let Some(account_seed) = account_seed {
diff --git a/miden-lib/src/transaction/memory.rs b/miden-lib/src/transaction/memory.rs
index 3cf55a9b3..5b8bc2c81 100644
--- a/miden-lib/src/transaction/memory.rs
+++ b/miden-lib/src/transaction/memory.rs
@@ -10,6 +10,17 @@ pub type StorageSlot = u8;
 // PUBLIC CONSTANTS
 // ================================================================================================
 
+// | Section           | Start address |  End address |
+// | -------------     | :------------:| :-----------:|
+// | Bookkeeping       | 0             | 4            |
+// | Global inputs     | 100           | 105          |
+// | Block header      | 200           | 207          |
+// | Chain MMR         | 300           | 332?         |
+// | Account data      | 400           | 651?         |
+// | Account procedures| 999           | ?            |
+// | Input notes       | 1_048_576     | ?            |
+// | Output notes      | 4_194_304     | ?            |
+
 // RESERVED ACCOUNT STORAGE SLOTS
 // ------------------------------------------------------------------------------------------------
 
@@ -117,14 +128,14 @@ pub const CHAIN_MMR_PEAKS_PTR: MemoryAddress = 301;
 // ACCOUNT DATA
 // ------------------------------------------------------------------------------------------------
 
-/// The size of the memory segment allocated to core account data (excluding new code root)
+/// The size of the memory segment allocated to core account data (excluding new code commitment)
 pub const ACCT_DATA_MEM_SIZE: MemSize = 4;
 
 /// The memory address at which the account data section begins
 pub const ACCT_DATA_SECTION_OFFSET: MemoryOffset = 400;
 
-/// The offset at which the account id and nonce is stored relative to the start of the account
-/// data segment.
+/// The offset at which the account id and nonce is stored relative to the start of
+/// the account data segment.
 pub const ACCT_ID_AND_NONCE_OFFSET: MemoryOffset = 0;
 
 /// The index of the account id within the account id and nonce data.
@@ -154,24 +165,31 @@ pub const ACCT_STORAGE_ROOT_OFFSET: MemoryOffset = 2;
 pub const ACCT_STORAGE_ROOT_PTR: MemoryAddress =
     ACCT_DATA_SECTION_OFFSET + ACCT_STORAGE_ROOT_OFFSET;
 
-/// The offset at which the account code root is stored relative to the start of the account
+/// The offset at which the account code commitment is stored relative to the start of the account
 /// data segment.
-pub const ACCT_CODE_ROOT_OFFSET: MemoryOffset = 3;
+pub const ACCT_CODE_COMMITMENT_OFFSET: MemoryOffset = 3;
 
-/// The memory address at which the account code root is stored.
-pub const ACCT_CODE_ROOT_PTR: MemoryAddress = ACCT_DATA_SECTION_OFFSET + ACCT_CODE_ROOT_OFFSET;
+/// The memory address at which the account code commitment is stored.
+pub const ACCT_CODE_COMMITMENT_PTR: MemoryAddress =
+    ACCT_DATA_SECTION_OFFSET + ACCT_CODE_COMMITMENT_OFFSET;
 
-/// The offset at which the accounts new code root is stored relative to the start of the account
+/// The offset at which the accounts new code commitment is stored relative to the start of the account
 /// data segment.
-pub const ACCT_NEW_CODE_ROOT_OFFSET: MemoryOffset = 4;
+pub const ACCT_NEW_CODE_COMMITMENT_OFFSET: MemoryOffset = 4;
 
-/// The memory address at which the new account code root is stored
-pub const ACCT_NEW_CODE_ROOT_PTR: MemoryAddress =
-    ACCT_DATA_SECTION_OFFSET + ACCT_NEW_CODE_ROOT_OFFSET;
+/// The memory address at which the new account code commitment is stored
+pub const ACCT_NEW_CODE_COMMITMENT_PTR: MemoryAddress =
+    ACCT_DATA_SECTION_OFFSET + ACCT_NEW_CODE_COMMITMENT_OFFSET;
 
-/// The memory address at which the account storage slot type data beings
+/// The memory address at which the account storage slot type data begins
 pub const ACCT_STORAGE_SLOT_TYPE_DATA_OFFSET: MemoryAddress = 405;
 
+/// The memory address at which the number of procedures contained in the account code is stored
+pub const NUM_ACCT_PROCEDURES_PTR: MemoryAddress = 999;
+
+/// The memory address at which the account procedures section begins.
+pub const ACCT_PROCEDURES_SECTION_OFFSET: MemoryAddress = 1000;
+
 // NOTES DATA
 // ================================================================================================
 
diff --git a/miden-lib/src/transaction/outputs.rs b/miden-lib/src/transaction/outputs.rs
index d7bd411a5..79f33767c 100644
--- a/miden-lib/src/transaction/outputs.rs
+++ b/miden-lib/src/transaction/outputs.rs
@@ -4,7 +4,7 @@ use miden_objects::{
 };
 
 use super::memory::{
-    ACCT_CODE_ROOT_OFFSET, ACCT_DATA_MEM_SIZE, ACCT_ID_AND_NONCE_OFFSET, ACCT_ID_IDX,
+    ACCT_CODE_COMMITMENT_OFFSET, ACCT_DATA_MEM_SIZE, ACCT_ID_AND_NONCE_OFFSET, ACCT_ID_IDX,
     ACCT_NONCE_IDX, ACCT_STORAGE_ROOT_OFFSET, ACCT_VAULT_ROOT_OFFSET,
 };
 
@@ -21,7 +21,7 @@ pub const FINAL_ACCOUNT_HASH_WORD_IDX: usize = 1;
 // ================================================================================================
 
 /// Parses the stub account data returned by the VM into individual account component commitments.
-/// Returns a tuple of account ID, vault root, storage root, code root, and nonce.
+/// Returns a tuple of account ID, vault root, storage root, code commitment, and nonce.
 pub fn parse_final_account_stub(elements: &[Word]) -> Result<AccountStub, AccountError> {
     if elements.len() != ACCT_DATA_MEM_SIZE {
         return Err(AccountError::StubDataIncorrectLength(elements.len(), ACCT_DATA_MEM_SIZE));
@@ -31,7 +31,7 @@ pub fn parse_final_account_stub(elements: &[Word]) -> Result<AccountStub, Accoun
     let nonce = elements[ACCT_ID_AND_NONCE_OFFSET as usize][ACCT_NONCE_IDX];
     let vault_root = elements[ACCT_VAULT_ROOT_OFFSET as usize].into();
     let storage_root = elements[ACCT_STORAGE_ROOT_OFFSET as usize].into();
-    let code_root = elements[ACCT_CODE_ROOT_OFFSET as usize].into();
+    let code_commitment = elements[ACCT_CODE_COMMITMENT_OFFSET as usize].into();
 
-    Ok(AccountStub::new(id, nonce, vault_root, storage_root, code_root))
+    Ok(AccountStub::new(id, nonce, vault_root, storage_root, code_commitment))
 }
diff --git a/miden-tx/src/compiler/mod.rs b/miden-tx/src/compiler/mod.rs
index c99f12d9a..dd336a16a 100644
--- a/miden-tx/src/compiler/mod.rs
+++ b/miden-tx/src/compiler/mod.rs
@@ -73,7 +73,10 @@ impl TransactionCompiler {
     ) -> Result<AccountCode, TransactionCompilerError> {
         let account_code = AccountCode::new(account_code, &self.assembler)
             .map_err(TransactionCompilerError::LoadAccountFailed)?;
-        self.account_procedures.insert(account_id, account_code.procedures().to_vec());
+
+        self.account_procedures
+            .insert(account_id, account_code.procedure_roots().collect::<Vec<_>>());
+
         Ok(account_code)
     }
 
diff --git a/miden-tx/src/compiler/tests.rs b/miden-tx/src/compiler/tests.rs
index 4ddb782e0..87280a444 100644
--- a/miden-tx/src/compiler/tests.rs
+++ b/miden-tx/src/compiler/tests.rs
@@ -62,7 +62,7 @@ fn test_load_account() {
 
     let acct_procs = [hex_to_bytes(ACCT_PROC_1), hex_to_bytes(ACCT_PROC_2)];
     for proc in account_code.procedures() {
-        assert!(acct_procs.contains(&proc.as_bytes().to_vec()));
+        assert!(acct_procs.contains(&proc.mast_root().as_bytes().to_vec()));
     }
 }
 
diff --git a/miden-tx/src/error.rs b/miden-tx/src/error.rs
index eabce6342..0d2093f6f 100644
--- a/miden-tx/src/error.rs
+++ b/miden-tx/src/error.rs
@@ -55,6 +55,7 @@ pub enum TransactionExecutorError {
     },
     InvalidTransactionOutput(TransactionOutputError),
     LoadAccountFailed(TransactionCompilerError),
+    TransactionHostCreationFailed(TransactionHostError),
 }
 
 impl fmt::Display for TransactionExecutorError {
@@ -75,6 +76,7 @@ pub enum TransactionProverError {
     InvalidAccountDelta(AccountError),
     InvalidTransactionOutput(TransactionOutputError),
     ProvenTransactionError(ProvenTransactionError),
+    TransactionHostCreationFailed(TransactionHostError),
 }
 
 impl Display for TransactionProverError {
@@ -92,6 +94,9 @@ impl Display for TransactionProverError {
             TransactionProverError::ProvenTransactionError(inner) => {
                 write!(f, "Building proven transaction error: {}", inner)
             },
+            TransactionProverError::TransactionHostCreationFailed(inner) => {
+                write!(f, "Failed to create the transaction host: {}", inner)
+            },
         }
     }
 }
@@ -117,6 +122,23 @@ impl fmt::Display for TransactionVerifierError {
 #[cfg(feature = "std")]
 impl std::error::Error for TransactionVerifierError {}
 
+// TRANSACTION HOST ERROR
+// ================================================================================================
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TransactionHostError {
+    AccountProcedureIndexMapError(String),
+}
+
+impl fmt::Display for TransactionHostError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TransactionHostError {}
+
 // DATA STORE ERROR
 // ================================================================================================
 
@@ -244,8 +266,12 @@ const ERR_NOTE_TAG_MUST_BE_U32: u32 = 131142;
 const ERR_SETTING_NON_VALUE_ITEM_ON_VALUE_SLOT: u32 = 131143;
 const ERR_SETTING_MAP_ITEM_ON_NON_MAP_SLOT: u32 = 131144;
 const ERR_READING_MAP_VALUE_FROM_NON_MAP_SLOT: u32 = 131145;
+const ERR_PROC_NOT_PART_OF_ACCOUNT_CODE: u32 = 131146;
+const ERR_PROC_INDEX_OUT_OF_BOUNDS: u32 = 131147;
+const ERR_ACCT_CODE_HASH_MISMATCH: u32 = 131148;
+const ERR_ACCT_TOO_MANY_PROCEDURES: u32 = 131149;
 
-pub const KERNEL_ERRORS: [(u32, &str); 75] = [
+pub const KERNEL_ERRORS: [(u32, &str); 79] = [
     (ERR_FAUCET_RESERVED_DATA_SLOT, "For faucets, storage slot 254 is reserved and can not be used with set_account_item procedure"),
     (ERR_ACCT_MUST_BE_A_FAUCET, "Procedure can only be called from faucet accounts"),
     (ERR_P2ID_WRONG_NUMBER_OF_INPUTS, "P2ID scripts expect exactly 1 note input"),
@@ -321,4 +347,8 @@ pub const KERNEL_ERRORS: [(u32, &str); 75] = [
     (ERR_SETTING_NON_VALUE_ITEM_ON_VALUE_SLOT, "Setting a non-value item on a value slot"),
     (ERR_SETTING_MAP_ITEM_ON_NON_MAP_SLOT, "Setting a map item on a non-map slot"),
     (ERR_READING_MAP_VALUE_FROM_NON_MAP_SLOT, "Slot type is not a map"),
+    (ERR_PROC_NOT_PART_OF_ACCOUNT_CODE, "Provided procedure is not part of account code"),
+    (ERR_PROC_INDEX_OUT_OF_BOUNDS, "Provided procedure index is out of bounds"),
+    (ERR_ACCT_CODE_HASH_MISMATCH, "Provided account hash does not match stored account hash"),
+    (ERR_ACCT_TOO_MANY_PROCEDURES, "Number of account procedures exceeded the maximum limit of 65535")
 ];
diff --git a/miden-tx/src/executor/mod.rs b/miden-tx/src/executor/mod.rs
index 307a5ccb6..f31536363 100644
--- a/miden-tx/src/executor/mod.rs
+++ b/miden-tx/src/executor/mod.rs
@@ -191,7 +191,8 @@ impl<D: DataStore, A: TransactionAuthenticator> TransactionExecutor<D, A> {
             transaction.account().into(),
             advice_recorder,
             self.authenticator.clone(),
-        );
+        )
+        .map_err(TransactionExecutorError::TransactionHostCreationFailed)?;
 
         let result = vm_processor::execute(
             transaction.program(),
diff --git a/miden-tx/src/host/account_procs.rs b/miden-tx/src/host/account_procs.rs
index 21d72c73d..273299136 100644
--- a/miden-tx/src/host/account_procs.rs
+++ b/miden-tx/src/host/account_procs.rs
@@ -1,40 +1,80 @@
+use alloc::string::ToString;
+
 use miden_lib::transaction::TransactionKernelError;
-use miden_objects::accounts::AccountCode;
+use miden_objects::accounts::{AccountCode, AccountProcedureInfo};
 
-use super::{AdviceProvider, BTreeMap, Digest, NodeIndex, ProcessState};
+use super::{AdviceProvider, BTreeMap, Digest, Felt, ProcessState};
+use crate::error::TransactionHostError;
 
 // ACCOUNT PROCEDURE INDEX MAP
 // ================================================================================================
 
 /// A map of proc_root |-> proc_index for all known procedures of an account interface.
-pub struct AccountProcedureIndexMap(BTreeMap<Digest, u8>);
+pub struct AccountProcedureIndexMap(BTreeMap<Digest, u16>);
 
 impl AccountProcedureIndexMap {
     /// Returns a new [AccountProcedureIndexMap] instantiated with account procedures present in
     /// the provided advice provider.
-    ///
-    /// This function assumes that the account procedure tree (or a part thereof) is loaded into the
-    /// Merkle store of the provided advice provider.
-    pub fn new<A: AdviceProvider>(account_code_root: Digest, adv_provider: &A) -> Self {
-        // get the Merkle store with the procedure tree from the advice provider
-        let proc_store = adv_provider.get_store_subset([account_code_root].iter());
+    pub fn new<A: AdviceProvider>(
+        account_code_commitment: Digest,
+        adv_provider: &A,
+    ) -> Result<Self, TransactionHostError> {
+        // get the account procedures from the advice_map
+        let proc_data =
+            adv_provider.get_mapped_values(&account_code_commitment).ok_or_else(|| {
+                TransactionHostError::AccountProcedureIndexMapError(
+                    "Failed to read account procedure data from the advice provider".to_string(),
+                )
+            })?;
 
-        // iterate over all possible procedure indexes
         let mut result = BTreeMap::new();
-        for i in 0..AccountCode::MAX_NUM_PROCEDURES {
-            let index = NodeIndex::new(AccountCode::PROCEDURE_TREE_DEPTH, i as u64)
-                .expect("procedure tree index is valid");
-            // if the node at the current index does not exist, skip it and try the next node;this
-            // situation is valid if not all account procedures are loaded into the advice provider
-            if let Ok(proc_root) = proc_store.get_node(account_code_root, index) {
-                // if we got an empty digest, this means we got to the end of the procedure list
-                if proc_root == Digest::default() {
-                    break;
-                }
-                result.insert(proc_root, i as u8);
-            }
+
+        // sanity checks
+
+        // check that there are procedures in the account code
+        if proc_data.is_empty() {
+            return Err(TransactionHostError::AccountProcedureIndexMapError(
+                "The account code does not contain any procedures.".to_string(),
+            ));
+        }
+
+        let num_procs = proc_data[0].as_int() as usize;
+
+        // check that the account code does not contain too many procedures
+        if num_procs > AccountCode::MAX_NUM_PROCEDURES {
+            return Err(TransactionHostError::AccountProcedureIndexMapError(
+                "The account code contains too many procedures.".to_string(),
+            ));
+        }
+
+        // check that the stored number of procedures matches the length of the procedures array
+        if num_procs * AccountProcedureInfo::NUM_ELEMENTS_PER_PROC != proc_data.len() - 1 {
+            return Err(TransactionHostError::AccountProcedureIndexMapError(
+                "Invalid number of procedures.".to_string(),
+            ));
         }
-        Self(result)
+
+        // we skip proc_data[0] because it's the number of procedures
+        for (proc_idx, proc_info) in proc_data[1..]
+            .chunks_exact(AccountProcedureInfo::NUM_ELEMENTS_PER_PROC)
+            .enumerate()
+        {
+            let proc_info_array: [Felt; AccountProcedureInfo::NUM_ELEMENTS_PER_PROC] =
+                proc_info.try_into().expect("Failed conversion into procedure info array.");
+
+            let procedure = AccountProcedureInfo::try_from(proc_info_array).map_err(|e| {
+                TransactionHostError::AccountProcedureIndexMapError(format!(
+                    "Failed to create AccountProcedureInfo: {:?}",
+                    e
+                ))
+            })?;
+
+            let proc_idx = u16::try_from(proc_idx).expect("Invalid procedure index.");
+
+            result.insert(*procedure.mast_root(), proc_idx);
+        }
+
+        Ok(Self(result))
     }
 
     /// Returns index of the procedure whose root is currently at the top of the operand stack in
@@ -46,8 +86,15 @@ impl AccountProcedureIndexMap {
     pub fn get_proc_index<S: ProcessState>(
         &self,
         process: &S,
-    ) -> Result<u8, TransactionKernelError> {
+    ) -> Result<u16, TransactionKernelError> {
         let proc_root = process.get_stack_word(0).into();
+
+        // mock account method for testing from root context
+        // TODO: figure out if we can get rid of this
+        if proc_root == Digest::default() {
+            return Ok(255);
+        }
+
         self.0
             .get(&proc_root)
             .cloned()
diff --git a/miden-tx/src/host/mod.rs b/miden-tx/src/host/mod.rs
index 5b9ce99a8..c5341025d 100644
--- a/miden-tx/src/host/mod.rs
+++ b/miden-tx/src/host/mod.rs
@@ -11,15 +11,15 @@ use miden_objects::{
     Digest, Hasher,
 };
 use vm_processor::{
-    crypto::NodeIndex, AdviceExtractor, AdviceInjector, AdviceProvider, AdviceSource, ContextId,
-    ExecutionError, Felt, Host, HostResponse, ProcessState,
+    AdviceExtractor, AdviceInjector, AdviceProvider, AdviceSource, ContextId, ExecutionError, Felt,
+    Host, HostResponse, ProcessState,
 };
 
 mod account_delta_tracker;
 use account_delta_tracker::AccountDeltaTracker;
 
 mod account_procs;
-use account_procs::AccountProcedureIndexMap;
+pub use account_procs::AccountProcedureIndexMap;
 
 mod note_builder;
 use note_builder::OutputNoteBuilder;
@@ -27,7 +27,7 @@ use note_builder::OutputNoteBuilder;
 mod tx_progress;
 pub use tx_progress::TransactionProgress;
 
-use crate::{auth::TransactionAuthenticator, KERNEL_ERRORS};
+use crate::{auth::TransactionAuthenticator, error::TransactionHostError, KERNEL_ERRORS};
 
 // CONSTANTS
 // ================================================================================================
@@ -69,10 +69,15 @@ pub struct TransactionHost<A, T> {
 
 impl<A: AdviceProvider, T: TransactionAuthenticator> TransactionHost<A, T> {
     /// Returns a new [TransactionHost] instance with the provided [AdviceProvider].
-    pub fn new(account: AccountStub, adv_provider: A, authenticator: Option<Rc<T>>) -> Self {
-        let proc_index_map = AccountProcedureIndexMap::new(account.code_root(), &adv_provider);
+    pub fn new(
+        account: AccountStub,
+        adv_provider: A,
+        authenticator: Option<Rc<T>>,
+    ) -> Result<Self, TransactionHostError> {
+        let proc_index_map =
+            AccountProcedureIndexMap::new(account.code_commitment(), &adv_provider)?;
         let kernel_assertion_errors = BTreeMap::from(KERNEL_ERRORS);
-        Self {
+        Ok(Self {
             adv_provider,
             account_delta: AccountDeltaTracker::new(&account),
             acct_procedure_index_map: proc_index_map,
@@ -81,7 +86,7 @@ impl<A: AdviceProvider, T: TransactionAuthenticator> TransactionHost<A, T> {
             tx_progress: TransactionProgress::default(),
             generated_signatures: BTreeMap::new(),
             error_messages: kernel_assertion_errors,
-        }
+        })
     }
 
     /// Consumes `self` and returns the advice provider and account vault delta.
diff --git a/miden-tx/src/prover/mod.rs b/miden-tx/src/prover/mod.rs
index c89a01652..f5759216d 100644
--- a/miden-tx/src/prover/mod.rs
+++ b/miden-tx/src/prover/mod.rs
@@ -50,7 +50,8 @@ impl TransactionProver {
         let (stack_inputs, advice_inputs) = tx_witness.get_kernel_inputs();
         let advice_provider: MemAdviceProvider = advice_inputs.into();
         let mut host: TransactionHost<_, ()> =
-            TransactionHost::new(tx_witness.account().into(), advice_provider, None);
+            TransactionHost::new(tx_witness.account().into(), advice_provider, None)
+                .map_err(TransactionProverError::TransactionHostCreationFailed)?;
         let (stack_outputs, proof) =
             prove(tx_witness.program(), stack_inputs, &mut host, self.proof_options.clone())
                 .map_err(TransactionProverError::ProveTransactionProgramFailed)?;
diff --git a/miden-tx/src/testing/account_procs.rs b/miden-tx/src/testing/account_procs.rs
deleted file mode 100644
index e52d24738..000000000
--- a/miden-tx/src/testing/account_procs.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use alloc::collections::BTreeMap;
-
-use miden_lib::transaction::TransactionKernelError;
-use miden_objects::accounts::AccountCode;
-use vm_processor::{crypto::NodeIndex, AdviceProvider, Digest, ProcessState};
-
-// ACCOUNT PROCEDURE INDEX MAP
-// ================================================================================================
-
-/// A map of proc_root |-> proc_index for all known procedures of an account interface.
-pub struct AccountProcedureIndexMap(BTreeMap<Digest, u8>);
-
-impl AccountProcedureIndexMap {
-    /// Returns a new [AccountProcedureIndexMap] instantiated with account procedures present in
-    /// the provided advice provider.
-    ///
-    /// This function assumes that the account procedure tree (or a part thereof) is loaded into the
-    /// Merkle store of the provided advice provider.
-    pub fn new<A: AdviceProvider>(account_code_root: Digest, adv_provider: &A) -> Self {
-        // get the Merkle store with the procedure tree from the advice provider
-        let proc_store = adv_provider.get_store_subset([account_code_root].iter());
-
-        // iterate over all possible procedure indexes
-        let mut result = BTreeMap::new();
-        for i in 0..AccountCode::MAX_NUM_PROCEDURES {
-            let index = NodeIndex::new(AccountCode::PROCEDURE_TREE_DEPTH, i as u64)
-                .expect("procedure tree index is valid");
-            // if the node at the current index does not exist, skip it and try the next node;this
-            // situation is valid if not all account procedures are loaded into the advice provider
-            if let Ok(proc_root) = proc_store.get_node(account_code_root, index) {
-                // if we got an empty digest, this means we got to the end of the procedure list
-                if proc_root == Digest::default() {
-                    break;
-                }
-                result.insert(proc_root, i as u8);
-            }
-        }
-        Self(result)
-    }
-
-    /// Returns index of the procedure whose root is currently at the top of the operand stack in
-    /// the provided process.
-    ///
-    /// # Errors
-    /// Returns an error if the procedure at the top of the operand stack is not present in this
-    /// map.
-    pub fn get_proc_index<S: ProcessState>(
-        &self,
-        process: &S,
-    ) -> Result<u8, TransactionKernelError> {
-        let proc_root = process.get_stack_word(0).into();
-        // mock account method for testing from root context
-        // TODO: figure out if we can get rid of this
-        if proc_root == Digest::default() {
-            return Ok(255);
-        }
-        self.0
-            .get(&proc_root)
-            .cloned()
-            .ok_or(TransactionKernelError::UnknownAccountProcedure(proc_root))
-    }
-}
diff --git a/miden-tx/src/testing/mock_host.rs b/miden-tx/src/testing/mock_host.rs
index 7580e6e2c..90f33b2e4 100644
--- a/miden-tx/src/testing/mock_host.rs
+++ b/miden-tx/src/testing/mock_host.rs
@@ -10,7 +10,7 @@ use vm_processor::{
     ExecutionError, Host, HostResponse, MemAdviceProvider, ProcessState,
 };
 
-use super::account_procs::AccountProcedureIndexMap;
+use crate::host::AccountProcedureIndexMap;
 
 // MOCK HOST
 // ================================================================================================
@@ -28,10 +28,11 @@ impl MockHost {
     /// Returns a new [MockHost] instance with the provided [AdviceInputs].
     pub fn new(account: AccountStub, advice_inputs: AdviceInputs) -> Self {
         let adv_provider: MemAdviceProvider = advice_inputs.into();
-        let proc_index_map = AccountProcedureIndexMap::new(account.code_root(), &adv_provider);
+        let proc_index_map =
+            AccountProcedureIndexMap::new(account.code_commitment(), &adv_provider);
         Self {
             adv_provider,
-            acct_procedure_index_map: proc_index_map,
+            acct_procedure_index_map: proc_index_map.unwrap(),
         }
     }
 
diff --git a/miden-tx/src/testing/mod.rs b/miden-tx/src/testing/mod.rs
index 9d8cf2670..50efb4e12 100644
--- a/miden-tx/src/testing/mod.rs
+++ b/miden-tx/src/testing/mod.rs
@@ -1,4 +1,3 @@
-mod account_procs;
 pub mod executor;
 
 pub use mock_host::MockHost;
diff --git a/miden-tx/src/tests/kernel_tests/test_account.rs b/miden-tx/src/tests/kernel_tests/test_account.rs
index bf384a98d..988bf14b1 100644
--- a/miden-tx/src/tests/kernel_tests/test_account.rs
+++ b/miden-tx/src/tests/kernel_tests/test_account.rs
@@ -1,4 +1,4 @@
-use miden_lib::transaction::memory::{ACCT_CODE_ROOT_PTR, ACCT_NEW_CODE_ROOT_PTR};
+use miden_lib::transaction::memory::{ACCT_CODE_COMMITMENT_PTR, ACCT_NEW_CODE_COMMITMENT_PTR};
 use miden_objects::{
     accounts::{
         account_id::testing::{
@@ -39,15 +39,15 @@ pub fn test_set_code_is_not_immediate() {
     let process = tx_context.execute_code(code).unwrap();
 
     assert_eq!(
-        read_root_mem_value(&process, ACCT_CODE_ROOT_PTR),
-        tx_context.account().code().root().as_elements(),
-        "the code root must not change immediately",
+        read_root_mem_value(&process, ACCT_CODE_COMMITMENT_PTR),
+        tx_context.account().code().commitment().as_elements(),
+        "the code commitment must not change immediately",
     );
 
     assert_eq!(
-        read_root_mem_value(&process, ACCT_NEW_CODE_ROOT_PTR),
+        read_root_mem_value(&process, ACCT_NEW_CODE_COMMITMENT_PTR),
         [ONE, Felt::new(2), Felt::new(3), Felt::new(4)],
-        "the code root must be cached",
+        "the code commitment must be cached",
     );
 }
 
@@ -86,9 +86,9 @@ pub fn test_set_code_succeeds() {
     let process = tx_context.execute_code(&code).unwrap();
 
     assert_eq!(
-        read_root_mem_value(&process, ACCT_CODE_ROOT_PTR),
+        read_root_mem_value(&process, ACCT_CODE_COMMITMENT_PTR),
         [ZERO, ONE, Felt::new(2), Felt::new(3)],
-        "the code root must change after the epilogue",
+        "the code commitment must change after the epilogue",
     );
 }
 
@@ -476,14 +476,15 @@ fn test_authenticate_procedure() {
     let tx_context = TransactionContextBuilder::with_standard_account(ONE).build();
     let account = tx_context.tx_inputs().account();
 
-    let proc0_index = LeafIndex::new(0).unwrap();
-    let proc1_index = LeafIndex::new(1).unwrap();
+    let tc_0: [Felt; 4] =
+        account.code().procedures()[0].mast_root().as_elements().try_into().unwrap();
+    let tc_1: [Felt; 4] =
+        account.code().procedures()[1].mast_root().as_elements().try_into().unwrap();
+    let tc_2: [Felt; 4] =
+        account.code().procedures()[2].mast_root().as_elements().try_into().unwrap();
 
-    let test_cases = vec![
-        (account.code().procedure_tree().get_leaf(&proc0_index), true),
-        (account.code().procedure_tree().get_leaf(&proc1_index), true),
-        ([ONE, ZERO, ONE, ZERO], false),
-    ];
+    let test_cases =
+        vec![(tc_0, true), ([ONE, ZERO, ONE, ZERO], false), (tc_1, true), (tc_2, true)];
 
     for (root, valid) in test_cases.into_iter() {
         let tx_context = TransactionContextBuilder::with_standard_account(ONE).build();
diff --git a/miden-tx/src/tests/kernel_tests/test_prologue.rs b/miden-tx/src/tests/kernel_tests/test_prologue.rs
index bac951b87..9c4fe782f 100644
--- a/miden-tx/src/tests/kernel_tests/test_prologue.rs
+++ b/miden-tx/src/tests/kernel_tests/test_prologue.rs
@@ -2,16 +2,16 @@ use alloc::{collections::BTreeMap, vec::Vec};
 
 use miden_lib::transaction::{
     memory::{
-        MemoryOffset, ACCT_CODE_ROOT_PTR, ACCT_DB_ROOT_PTR, ACCT_ID_AND_NONCE_PTR, ACCT_ID_PTR,
-        ACCT_STORAGE_ROOT_PTR, ACCT_STORAGE_SLOT_TYPE_DATA_OFFSET, ACCT_VAULT_ROOT_PTR,
-        BLK_HASH_PTR, BLOCK_METADATA_PTR, BLOCK_NUMBER_IDX, CHAIN_MMR_NUM_LEAVES_PTR,
-        CHAIN_MMR_PEAKS_PTR, CHAIN_ROOT_PTR, INIT_ACCT_HASH_PTR, INIT_NONCE_PTR,
-        INPUT_NOTES_COMMITMENT_PTR, INPUT_NOTE_ARGS_OFFSET, INPUT_NOTE_ASSETS_HASH_OFFSET,
-        INPUT_NOTE_ASSETS_OFFSET, INPUT_NOTE_ID_OFFSET, INPUT_NOTE_INPUTS_HASH_OFFSET,
-        INPUT_NOTE_METADATA_OFFSET, INPUT_NOTE_NUM_ASSETS_OFFSET, INPUT_NOTE_SCRIPT_ROOT_OFFSET,
-        INPUT_NOTE_SECTION_OFFSET, INPUT_NOTE_SERIAL_NUM_OFFSET, NOTE_ROOT_PTR,
-        NULLIFIER_DB_ROOT_PTR, PREV_BLOCK_HASH_PTR, PROOF_HASH_PTR, PROTOCOL_VERSION_IDX,
-        TIMESTAMP_IDX, TX_HASH_PTR, TX_SCRIPT_ROOT_PTR,
+        MemoryOffset, ACCT_CODE_COMMITMENT_PTR, ACCT_DB_ROOT_PTR, ACCT_ID_AND_NONCE_PTR,
+        ACCT_ID_PTR, ACCT_PROCEDURES_SECTION_OFFSET, ACCT_STORAGE_ROOT_PTR,
+        ACCT_STORAGE_SLOT_TYPE_DATA_OFFSET, ACCT_VAULT_ROOT_PTR, BLK_HASH_PTR, BLOCK_METADATA_PTR,
+        BLOCK_NUMBER_IDX, CHAIN_MMR_NUM_LEAVES_PTR, CHAIN_MMR_PEAKS_PTR, CHAIN_ROOT_PTR,
+        INIT_ACCT_HASH_PTR, INIT_NONCE_PTR, INPUT_NOTES_COMMITMENT_PTR, INPUT_NOTE_ARGS_OFFSET,
+        INPUT_NOTE_ASSETS_HASH_OFFSET, INPUT_NOTE_ASSETS_OFFSET, INPUT_NOTE_ID_OFFSET,
+        INPUT_NOTE_INPUTS_HASH_OFFSET, INPUT_NOTE_METADATA_OFFSET, INPUT_NOTE_NUM_ASSETS_OFFSET,
+        INPUT_NOTE_SCRIPT_ROOT_OFFSET, INPUT_NOTE_SECTION_OFFSET, INPUT_NOTE_SERIAL_NUM_OFFSET,
+        NOTE_ROOT_PTR, NULLIFIER_DB_ROOT_PTR, NUM_ACCT_PROCEDURES_PTR, PREV_BLOCK_HASH_PTR,
+        PROOF_HASH_PTR, PROTOCOL_VERSION_IDX, TIMESTAMP_IDX, TX_HASH_PTR, TX_SCRIPT_ROOT_PTR,
     },
     TransactionKernel,
 };
@@ -238,8 +238,8 @@ fn account_data_memory_assertions(process: &Process<MockHost>, inputs: &Transact
     );
 
     assert_eq!(
-        read_root_mem_value(process, ACCT_CODE_ROOT_PTR),
-        inputs.account().code().root().as_elements(),
+        read_root_mem_value(process, ACCT_CODE_COMMITMENT_PTR),
+        inputs.account().code().commitment().as_elements(),
         "account code commitment should be stored at (ACCOUNT_DATA_OFFSET + 4)"
     );
 
@@ -256,6 +256,25 @@ fn account_data_memory_assertions(process: &Process<MockHost>, inputs: &Transact
             "The account types data should be stored in (ACCT_STORAGE_SLOT_TYPE_DATA_OFFSET..ACCT_STORAGE_SLOT_TYPE_DATA_OFFSET + 64)"
         );
     }
+
+    assert_eq!(
+        read_root_mem_value(process, NUM_ACCT_PROCEDURES_PTR),
+        [
+            u16::try_from(inputs.account().code().procedures().len()).unwrap().into(),
+            ZERO,
+            ZERO,
+            ZERO
+        ],
+        "The number of procedures should be stored at NUM_ACCT_PROCEDURES_PTR"
+    );
+
+    for (i, elements) in inputs.account().code().as_elements().chunks(4).enumerate() {
+        assert_eq!(
+            read_root_mem_value(process, ACCT_PROCEDURES_SECTION_OFFSET + i as u32),
+            Word::try_from(elements).unwrap(),
+            "The account procedures and storage offsets should be stored starting at ACCT_PROCEDURES_SECTION_OFFSET"
+        );
+    }
 }
 
 fn input_notes_memory_assertions(
diff --git a/miden-tx/src/tests/mod.rs b/miden-tx/src/tests/mod.rs
index f05e0e1e4..697890b69 100644
--- a/miden-tx/src/tests/mod.rs
+++ b/miden-tx/src/tests/mod.rs
@@ -73,7 +73,7 @@ fn transaction_executor_witness() {
     let mem_advice_provider: MemAdviceProvider = advice_inputs.into();
     let _authenticator = ();
     let mut host: TransactionHost<MemAdviceProvider, ()> =
-        TransactionHost::new(tx_witness.account().into(), mem_advice_provider, None);
+        TransactionHost::new(tx_witness.account().into(), mem_advice_provider, None).unwrap();
     let result =
         vm_processor::execute(tx_witness.program(), stack_inputs, &mut host, Default::default())
             .unwrap();
@@ -262,7 +262,7 @@ fn executed_transaction_account_delta() {
 
             ## Update account code
             ## ------------------------------------------------------------------------------------
-            push.{NEW_ACCOUNT_ROOT} exec.set_code dropw
+            push.{NEW_ACCOUNT_COMMITMENT} exec.set_code dropw
             # => []
 
             ## Update the account nonce
@@ -271,7 +271,7 @@ fn executed_transaction_account_delta() {
             # => []
         end
     ",
-        NEW_ACCOUNT_ROOT = prepare_word(&new_acct_code.root()),
+        NEW_ACCOUNT_COMMITMENT = prepare_word(&new_acct_code.commitment()),
         UPDATED_SLOT_VALUE = prepare_word(&Word::from(updated_slot_value)),
         UPDATED_MAP_VALUE = prepare_word(&Word::from(updated_map_value)),
         UPDATED_MAP_KEY = prepare_word(&Word::from(updated_map_key)),
@@ -382,11 +382,11 @@ fn test_empty_delta_nonce_update() {
     let tx_script = format!(
         "\
         begin
-            push.1 
-            
+            push.1
+
             call.{ACCOUNT_INCR_NONCE_MAST_ROOT}
             # => [0, 1]
-            
+
             drop drop
             # => []
         end
diff --git a/miden-tx/tests/integration/wallet/mod.rs b/miden-tx/tests/integration/wallet/mod.rs
index 8a966bfd4..a02d0ce07 100644
--- a/miden-tx/tests/integration/wallet/mod.rs
+++ b/miden-tx/tests/integration/wallet/mod.rs
@@ -223,13 +223,13 @@ fn wallet_creation() {
 
     // sender_account_id not relevant here, just to create a default account code
     let sender_account_id = AccountId::try_from(ACCOUNT_ID_SENDER).unwrap();
-    let expected_code_root =
+    let expected_code_commitment =
         get_account_with_default_account_code(sender_account_id, pub_key.into(), None)
             .code()
-            .root();
+            .commitment();
 
     assert!(wallet.is_regular_account());
-    assert_eq!(wallet.code().root(), expected_code_root);
+    assert_eq!(wallet.code().commitment(), expected_code_commitment);
     let pub_key_word: Word = pub_key.into();
     assert_eq!(wallet.storage().get_item(0).as_elements(), pub_key_word);
 }
diff --git a/objects/src/accounts/account_id.rs b/objects/src/accounts/account_id.rs
index ed9a93cc0..4f9df5e7c 100644
--- a/objects/src/accounts/account_id.rs
+++ b/objects/src/accounts/account_id.rs
@@ -126,15 +126,15 @@ impl AccountId {
     // CONSTRUCTORS
     // --------------------------------------------------------------------------------------------
 
-    /// Returns a new account ID derived from the specified seed, code root and storage root.
+    /// Returns a new account ID derived from the specified seed, code commitment and storage root.
     ///
-    /// The account ID is computed by hashing the seed, code root and storage root and using 1
+    /// The account ID is computed by hashing the seed, code commitment and storage root and using 1
     /// element of the resulting digest to form the ID. Specifically we take element 0. We also
     /// require that the last element of the seed digest has at least `23` trailing zeros if it
     /// is a regular account, or `31` trailing zeros if it is a faucet account.
     ///
     /// The seed digest is computed using a sequential hash over
-    /// hash(SEED, CODE_ROOT, STORAGE_ROOT, ZERO).  This takes two permutations.
+    /// hash(SEED, CODE_COMMITMENT, STORAGE_ROOT, ZERO).  This takes two permutations.
     ///
     /// # Errors
     /// Returns an error if the resulting account ID does not comply with account ID rules:
@@ -143,8 +143,12 @@ impl AccountId {
     /// - the last element of the seed digest has at least `23` trailing zeros for regular
     ///   accounts.
     /// - the last element of the seed digest has at least `31` trailing zeros for faucet accounts.
-    pub fn new(seed: Word, code_root: Digest, storage_root: Digest) -> Result<Self, AccountError> {
-        let seed_digest = compute_digest(seed, code_root, storage_root);
+    pub fn new(
+        seed: Word,
+        code_commitment: Digest,
+        storage_root: Digest,
+    ) -> Result<Self, AccountError> {
+        let seed_digest = compute_digest(seed, code_commitment, storage_root);
 
         Self::validate_seed_digest(&seed_digest)?;
         seed_digest[0].try_into()
@@ -161,19 +165,19 @@ impl AccountId {
     /// Creates a new dummy [AccountId] for testing purposes.
     #[cfg(any(feature = "testing", test))]
     pub fn new_dummy(init_seed: [u8; 32], account_type: AccountType) -> Self {
-        let code_root = Digest::default();
+        let code_commitment = Digest::default();
         let storage_root = Digest::default();
 
         let seed = get_account_seed(
             init_seed,
             account_type,
             AccountStorageType::OnChain,
-            code_root,
+            code_commitment,
             storage_root,
         )
         .unwrap();
 
-        Self::new(seed, code_root, storage_root).unwrap()
+        Self::new(seed, code_commitment, storage_root).unwrap()
     }
 
     // PUBLIC ACCESSORS
@@ -218,10 +222,10 @@ impl AccountId {
         init_seed: [u8; 32],
         account_type: AccountType,
         storage_type: AccountStorageType,
-        code_root: Digest,
+        code_commitment: Digest,
         storage_root: Digest,
     ) -> Result<Word, AccountError> {
-        get_account_seed(init_seed, account_type, storage_type, code_root, storage_root)
+        get_account_seed(init_seed, account_type, storage_type, code_commitment, storage_root)
     }
 
     /// Creates an Account Id from a hex string. Assumes the string starts with "0x" and
@@ -399,12 +403,12 @@ fn parse_felt(bytes: &[u8]) -> Result<Felt, AccountError> {
     Felt::try_from(bytes).map_err(|err| AccountError::AccountIdInvalidFieldElement(err.to_string()))
 }
 
-/// Returns the digest of two hashing permutations over the seed, code root, storage root and
+/// Returns the digest of two hashing permutations over the seed, code commitment, storage root and
 /// padding.
-pub(super) fn compute_digest(seed: Word, code_root: Digest, storage_root: Digest) -> Digest {
+pub(super) fn compute_digest(seed: Word, code_commitment: Digest, storage_root: Digest) -> Digest {
     let mut elements = Vec::with_capacity(16);
     elements.extend(seed);
-    elements.extend(*code_root);
+    elements.extend(*code_commitment);
     elements.extend(*storage_root);
     elements.resize(16, ZERO);
     Hasher::hash_elements(&elements)
diff --git a/objects/src/accounts/code.rs b/objects/src/accounts/code/mod.rs
similarity index 53%
rename from objects/src/accounts/code.rs
rename to objects/src/accounts/code/mod.rs
index 0f43ee76e..bc8f25c0e 100644
--- a/objects/src/accounts/code.rs
+++ b/objects/src/accounts/code/mod.rs
@@ -4,9 +4,11 @@ use assembly::ast::AstSerdeOptions;
 
 use super::{
     AccountError, Assembler, AssemblyContext, ByteReader, ByteWriter, Deserializable,
-    DeserializationError, Digest, ModuleAst, Serializable,
+    DeserializationError, Digest, Felt, Hasher, ModuleAst, Serializable,
 };
-use crate::crypto::merkle::SimpleSmt;
+
+pub mod procedure;
+use procedure::AccountProcedureInfo;
 
 // CONSTANTS
 // ================================================================================================
@@ -14,33 +16,39 @@ use crate::crypto::merkle::SimpleSmt;
 /// Default serialization options for account code AST.
 const MODULE_SERDE_OPTIONS: AstSerdeOptions = AstSerdeOptions::new(false);
 
-/// The depth of the Merkle tree that is used to commit to the account's public interface.
-pub const PROCEDURE_TREE_DEPTH: u8 = 8;
-
 // ACCOUNT CODE
 // ================================================================================================
 
 /// A public interface of an account.
 ///
-/// Account's public interface consists of a set of account procedures, each procedure being a Miden
-/// VM program. Thus, MAST root of each procedure commits to the underlying program. We commit to
-/// the entire account interface by building a simple Merkle tree out of all procedure MAST roots.
+/// Account's public interface consists of a set of account procedures, each procedure being a
+/// Miden VM program. Thus, MAST root of each procedure commits to the underlying program.
+///
+/// Each exported procedure is associated with a storage offset. This offset is applied to any
+/// accesses made from within the procedure to the associated account's storage. For example, if
+/// storage offset for a procedure is set ot 1, a call to the account::get_item(storage_slot=4)
+/// made from this procedure would actually access storage slot with index 5.
+///
+/// We commit to the entire account interface by building a sequential hash of all procedure MAST
+/// roots and associated storage_offset's. Specifically, each procedure contributes exactly 8 field
+/// elements to the sequence of elements to be hashed. These elements are defined as follows:
+///
+/// ```text
+/// [PROCEDURE_MAST_ROOT, storage_offset, 0, 0, 0]
+/// ```
 #[derive(Debug, Clone)]
 pub struct AccountCode {
     module: ModuleAst,
-    procedures: Vec<Digest>,
-    procedure_tree: SimpleSmt<PROCEDURE_TREE_DEPTH>,
+    procedures: Vec<AccountProcedureInfo>,
+    commitment: Digest,
 }
 
 impl AccountCode {
     // CONSTANTS
     // --------------------------------------------------------------------------------------------
 
-    /// The depth of the Merkle tree that is used to commit to the account's public interface.
-    pub const PROCEDURE_TREE_DEPTH: u8 = PROCEDURE_TREE_DEPTH;
-
     /// The maximum number of account interface procedures.
-    pub const MAX_NUM_PROCEDURES: usize = 2_usize.pow(Self::PROCEDURE_TREE_DEPTH as u32);
+    pub const MAX_NUM_PROCEDURES: usize = u16::MAX as usize;
 
     // CONSTRUCTOR
     // --------------------------------------------------------------------------------------------
@@ -50,13 +58,20 @@ impl AccountCode {
     /// Returns an error if:
     /// - Compilation of the provided module fails.
     /// - The number of procedures exported from the provided module is smaller than 1 or greater
-    ///   than 256.
+    ///   than 65535.
     pub fn new(module: ModuleAst, assembler: &Assembler) -> Result<Self, AccountError> {
         // compile the module and make sure the number of exported procedures is within the limit
         let procedures = assembler
             .compile_module(&module, None, &mut AssemblyContext::for_module(false))
             .map_err(AccountError::AccountCodeAssemblerError)?;
 
+        // TODO: Find way to input offset
+        let procedures: Vec<AccountProcedureInfo> = procedures
+            .into_iter()
+            .enumerate()
+            .map(|(i, proc)| AccountProcedureInfo::new(proc, i as u16))
+            .collect();
+
         // make sure the number of procedures is between 1 and 256 (both inclusive)
         if procedures.is_empty() {
             return Err(AccountError::AccountCodeNoProcedures);
@@ -68,27 +83,27 @@ impl AccountCode {
         }
 
         Ok(Self {
-            procedure_tree: build_procedure_tree(&procedures),
-            module,
+            commitment: build_procedure_commitment(&procedures),
             procedures,
+            module,
         })
     }
 
-    /// Returns a new definition of an account's interface instantiated from the provided
-    /// module and list of procedure digests.
+    /// Returns a new definition of an account's interface instantiated from the provided module
+    /// and list of [AccountProcedureInfo]s.
     ///
-    /// **Note**: this function assumes that the list of provided procedure digests results from
-    /// the compilation of the provided module, but this is not checked.
+    /// **Note**: this function assumes that the list of provided procedures results from the
+    /// compilation of the provided module, but this is not checked.
     ///
     /// # Panics
-    /// Panics if the number of procedures is smaller than 1 or greater than 256.
-    pub fn from_parts(module: ModuleAst, procedures: Vec<Digest>) -> Self {
+    /// Panics if the number of procedures is smaller than 1 or greater than 65535.
+    pub fn from_parts(module: ModuleAst, procedures: Vec<AccountProcedureInfo>) -> Self {
         assert!(!procedures.is_empty(), "no account procedures");
         assert!(procedures.len() <= Self::MAX_NUM_PROCEDURES, "too many account procedures");
         Self {
-            procedure_tree: build_procedure_tree(&procedures),
-            module,
+            commitment: build_procedure_commitment(&procedures),
             procedures,
+            module,
         }
     }
 
@@ -96,47 +111,61 @@ impl AccountCode {
     // --------------------------------------------------------------------------------------------
 
     /// Returns a commitment to an account's public interface.
-    pub fn root(&self) -> Digest {
-        self.procedure_tree().root()
+    pub fn commitment(&self) -> Digest {
+        self.commitment
     }
 
-    /// Returns a reference to the [ModuleAst] backing the [AccountCode].
+    /// Returns a reference to the [ModuleAst] backing this [AccountCode].
     pub fn module(&self) -> &ModuleAst {
         &self.module
     }
 
-    /// Returns a reference to the account procedure digests.
-    pub fn procedures(&self) -> &[Digest] {
+    /// Returns a reference to the account procedures.
+    pub fn procedures(&self) -> &[AccountProcedureInfo] {
         &self.procedures
     }
 
-    /// Returns a reference to the procedure tree.
-    pub fn procedure_tree(&self) -> &SimpleSmt<PROCEDURE_TREE_DEPTH> {
-        &self.procedure_tree
+    /// Returns an iterator over the procedure MAST roots of this [AccountCode].
+    pub fn procedure_roots(&self) -> impl Iterator<Item = Digest> + '_ {
+        self.procedures().iter().map(|procedure| *procedure.mast_root())
     }
 
-    /// Returns the number of public interface procedures defined for this account.
+    /// Returns the number of public interface procedures defined in this [AccountCode].
     pub fn num_procedures(&self) -> usize {
         self.procedures.len()
     }
 
-    /// Returns true if a procedure with the specified root is defined for this account.
-    pub fn has_procedure(&self, root: Digest) -> bool {
-        self.procedures.contains(&root)
+    /// Returns true if a procedure with the specified MAST root is defined in this [AccountCode].
+    pub fn has_procedure(&self, mast_root: Digest) -> bool {
+        self.procedures.iter().any(|procedure| procedure.mast_root() == &mast_root)
     }
 
-    /// Returns a procedure digest for the procedure with the specified index.
+    /// Returns information about the procedure at the specified index.
     ///
     /// # Panics
     /// Panics if the provided index is out of bounds.
-    pub fn get_procedure_by_index(&self, index: usize) -> Digest {
-        self.procedures[index]
+    pub fn get_procedure_by_index(&self, index: usize) -> &AccountProcedureInfo {
+        &self.procedures[index]
     }
 
-    /// Returns the procedure index for the procedure with the specified root or None if such
-    /// procedure is not defined for this account.
+    /// Returns the procedure index for the procedure with the specified MAST root or None if such
+    /// procedure is not defined in this [AccountCode].
     pub fn get_procedure_index_by_root(&self, root: Digest) -> Option<usize> {
-        self.procedures.iter().position(|r| r == &root)
+        self.procedures
+            .iter()
+            .map(|procedure| procedure.mast_root())
+            .position(|r| r == &root)
+    }
+
+    /// Converts procedure information in this [AccountCode] into a vector of field elements.
+    ///
+    /// This is done by first converting each procedure into exactly 8 elements as follows:
+    /// ```text
+    /// [PROCEDURE_MAST_ROOT, storage_offset, 0, 0, 0]
+    /// ```
+    /// And then concatenating the resulting elements into a single vector.
+    pub fn as_elements(&self) -> Vec<Felt> {
+        procedures_as_elements(self.procedures())
     }
 }
 
@@ -171,7 +200,7 @@ impl Deserializable for AccountCode {
         // debug info (this includes module imports and source locations) is not serialized with account code
         let module = ModuleAst::read_from(source, MODULE_SERDE_OPTIONS)?;
         let num_procedures = (source.read_u8()? as usize) + 1;
-        let procedures = source.read_many::<Digest>(num_procedures)?;
+        let procedures = source.read_many::<AccountProcedureInfo>(num_procedures)?;
 
         Ok(Self::from_parts(module, procedures))
     }
@@ -180,22 +209,18 @@ impl Deserializable for AccountCode {
 // HELPER FUNCTIONS
 // ================================================================================================
 
-fn build_procedure_tree(procedures: &[Digest]) -> SimpleSmt<PROCEDURE_TREE_DEPTH> {
-    // order the procedure digests to achieve a reproducible tree
-    let procedures = {
-        let mut procedures = procedures.to_vec();
-        procedures.sort_by_key(|a| a.as_bytes());
-        procedures
-    };
+/// Converts given procedures into field elements
+fn procedures_as_elements(procedures: &[AccountProcedureInfo]) -> Vec<Felt> {
+    procedures
+        .iter()
+        .flat_map(|procedure| <[Felt; 8]>::from(procedure.clone()))
+        .collect()
+}
 
-    SimpleSmt::<PROCEDURE_TREE_DEPTH>::with_leaves(
-        procedures
-            .iter()
-            .enumerate()
-            .map(|(idx, p)| (idx as u64, p.into()))
-            .collect::<Vec<_>>(),
-    )
-    .expect("failed to build procedure tree")
+/// Computes the commitment to the given procedures
+fn build_procedure_commitment(procedures: &[AccountProcedureInfo]) -> Digest {
+    let elements = procedures_as_elements(procedures);
+    Hasher::hash_elements(&elements)
 }
 
 // TESTS
@@ -203,13 +228,43 @@ fn build_procedure_tree(procedures: &[Digest]) -> SimpleSmt<PROCEDURE_TREE_DEPTH
 
 #[cfg(test)]
 mod tests {
+    use assembly::{ast::ModuleAst, Assembler};
+
     use super::{AccountCode, Deserializable, Serializable};
+    use crate::accounts::code::build_procedure_commitment;
+
+    const CODE: &str = "
+        export.foo
+            push.1 push.2 mul
+        end
+
+        export.bar
+            push.1 push.2 add
+        end
+    ";
+
+    fn make_account_code() -> AccountCode {
+        let mut module = ModuleAst::parse(CODE).unwrap();
+        // clears are needed since they're not serialized for account code
+        module.clear_imports();
+        module.clear_locations();
+        AccountCode::new(module, &Assembler::default()).unwrap()
+    }
 
     #[test]
     fn test_serde() {
-        let code = AccountCode::mock();
+        let code = make_account_code();
         let serialized = code.to_bytes();
         let deserialized = AccountCode::read_from_bytes(&serialized).unwrap();
         assert_eq!(deserialized, code)
     }
+
+    #[test]
+    fn test_account_code_procedure_commitment() {
+        let code = make_account_code();
+
+        let procedure_commitment = build_procedure_commitment(code.procedures());
+
+        assert_eq!(procedure_commitment, code.commitment())
+    }
 }
diff --git a/objects/src/accounts/code/procedure.rs b/objects/src/accounts/code/procedure.rs
new file mode 100644
index 000000000..6720033e9
--- /dev/null
+++ b/objects/src/accounts/code/procedure.rs
@@ -0,0 +1,134 @@
+use vm_core::{
+    utils::{ByteReader, ByteWriter, Deserializable, Serializable},
+    FieldElement,
+};
+use vm_processor::DeserializationError;
+
+use super::{Digest, Felt};
+use crate::AccountError;
+
+// ACCOUNT PROCEDURE INFO
+// ================================================================================================
+
+/// Information about a procedure exposed in a public account interface.
+///
+/// The info included the MAST root of the procedure and the storage offset applied to all account
+/// storage-related accesses made by this procedure. For example, if storage offset is set ot 1, a
+/// call to the account::get_item(storage_slot=4) made from this procedure would actually access
+/// storage slot with index 5.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct AccountProcedureInfo {
+    mast_root: Digest,
+    storage_offset: u16,
+}
+
+impl AccountProcedureInfo {
+    /// The number of field elements needed to represent an [AccountProcedureInfo] in kernel memory.
+    pub const NUM_ELEMENTS_PER_PROC: usize = 8;
+
+    /// Returns a new instance of an [AccountProcedureInfo].
+    pub fn new(mast_root: Digest, storage_offset: u16) -> Self {
+        Self { mast_root, storage_offset }
+    }
+
+    /// Returns a reference to the procedure's mast_root.
+    pub fn mast_root(&self) -> &Digest {
+        &self.mast_root
+    }
+
+    /// Returns a reference to the procedure's storage_offset.
+    pub fn storage_offset(&self) -> u16 {
+        self.storage_offset
+    }
+}
+
+impl From<AccountProcedureInfo> for [Felt; 8] {
+    fn from(value: AccountProcedureInfo) -> Self {
+        let mut result = [Felt::ZERO; 8];
+
+        // copy mast_root into first 4 elements
+        result[0..4].copy_from_slice(value.mast_root().as_elements());
+
+        // copy the storage offset into value[4]
+        result[4] = Felt::from(value.storage_offset());
+
+        result
+    }
+}
+
+impl TryFrom<[Felt; 8]> for AccountProcedureInfo {
+    type Error = AccountError;
+
+    fn try_from(value: [Felt; 8]) -> Result<Self, Self::Error> {
+        // get mast_root from first 4 elements
+        let mast_root = Digest::from(<[Felt; 4]>::try_from(&value[0..4]).unwrap());
+
+        // get storage_offset form value[4]
+        let storage_offset: u16 = value[4]
+            .try_into()
+            .map_err(|_| AccountError::AccountCodeProcedureInvalidStorageOffset)?;
+
+        // Check if the last three elements are zero
+        if value[5..].iter().any(|&x| x != Felt::ZERO) {
+            return Err(AccountError::AccountCodeProcedureInvalidPadding);
+        }
+
+        Ok(Self { mast_root, storage_offset })
+    }
+}
+
+impl Serializable for AccountProcedureInfo {
+    fn write_into<W: ByteWriter>(&self, target: &mut W) {
+        target.write(self.mast_root());
+        target.write_u16(self.storage_offset());
+    }
+}
+
+impl Deserializable for AccountProcedureInfo {
+    fn read_from<R: ByteReader>(source: &mut R) -> Result<Self, DeserializationError> {
+        let mast_root: Digest = source.read()?;
+        let storage_offset = source.read_u16()?;
+
+        Ok(Self::new(mast_root, storage_offset))
+    }
+}
+
+// TESTS
+// ================================================================================================
+
+#[cfg(test)]
+mod tests {
+
+    use assembly::{ast::ModuleAst, Assembler};
+    use miden_crypto::utils::{Deserializable, Serializable};
+
+    use crate::accounts::{AccountCode, AccountProcedureInfo};
+
+    const CODE: &str = "
+        export.foo
+            push.1 push.2 mul
+        end
+
+        export.bar
+            push.1 push.2 add
+        end
+    ";
+
+    fn make_account_code() -> AccountCode {
+        let mut module = ModuleAst::parse(CODE).unwrap();
+        // clears are needed since they're not serialized for account code
+        module.clear_imports();
+        module.clear_locations();
+        AccountCode::new(module, &Assembler::default()).unwrap()
+    }
+
+    #[test]
+    fn test_serde_account_procedure() {
+        let account_code = make_account_code();
+
+        let serialized = account_code.procedures()[0].to_bytes();
+        let deserialized = AccountProcedureInfo::read_from_bytes(&serialized).unwrap();
+
+        assert_eq!(deserialized, account_code.procedures()[0]);
+    }
+}
diff --git a/objects/src/accounts/mod.rs b/objects/src/accounts/mod.rs
index f751697c4..e3a1c9253 100644
--- a/objects/src/accounts/mod.rs
+++ b/objects/src/accounts/mod.rs
@@ -15,7 +15,7 @@ pub mod auth;
 pub use auth::AuthSecretKey;
 
 pub mod code;
-pub use code::AccountCode;
+pub use code::{procedure::AccountProcedureInfo, AccountCode};
 
 pub mod delta;
 pub use delta::{AccountDelta, AccountStorageDelta, AccountVaultDelta, StorageMapDelta};
@@ -75,7 +75,7 @@ impl Account {
         code: AccountCode,
         storage: AccountStorage,
     ) -> Result<Self, AccountError> {
-        let id = AccountId::new(seed, code.root(), storage.root())?;
+        let id = AccountId::new(seed, code.commitment(), storage.root())?;
         let vault = AssetVault::default();
         let nonce = ZERO;
         Ok(Self { id, vault, storage, code, nonce })
@@ -97,7 +97,7 @@ impl Account {
 
     /// Returns hash of this account.
     ///
-    /// Hash of an account is computed as hash(id, nonce, vault_root, storage_root, code_root).
+    /// Hash of an account is computed as hash(id, nonce, vault_root, storage_root, code_commitment).
     /// Computing the account hash requires 2 permutations of the hash function.
     pub fn hash(&self) -> Digest {
         hash_account(
@@ -105,7 +105,7 @@ impl Account {
             self.nonce,
             self.vault.commitment(),
             self.storage.root(),
-            self.code.root(),
+            self.code.commitment(),
         )
     }
 
@@ -287,23 +287,24 @@ impl<'de> serde::Deserialize<'de> for Account {
 // HELPERS
 // ================================================================================================
 
-/// Returns hash of an account with the specified ID, nonce, vault root, storage root, and code root.
+/// Returns hash of an account with the specified ID, nonce, vault root, storage root, and code
+/// commitment.
 ///
-/// Hash of an account is computed as hash(id, nonce, vault_root, storage_root, code_root).
+/// Hash of an account is computed as hash(id, nonce, vault_root, storage_root, code_commitment).
 /// Computing the account hash requires 2 permutations of the hash function.
 pub fn hash_account(
     id: AccountId,
     nonce: Felt,
     vault_root: Digest,
     storage_root: Digest,
-    code_root: Digest,
+    code_commitment: Digest,
 ) -> Digest {
     let mut elements = [ZERO; 16];
     elements[0] = id.into();
     elements[3] = nonce;
     elements[4..8].copy_from_slice(&*vault_root);
     elements[8..12].copy_from_slice(&*storage_root);
-    elements[12..].copy_from_slice(&*code_root);
+    elements[12..].copy_from_slice(&*code_commitment);
     Hasher::hash_elements(&elements)
 }
 
diff --git a/objects/src/accounts/seed.rs b/objects/src/accounts/seed.rs
index bdacc1634..eaa465617 100644
--- a/objects/src/accounts/seed.rs
+++ b/objects/src/accounts/seed.rs
@@ -23,7 +23,7 @@ pub fn get_account_seed(
     init_seed: [u8; 32],
     account_type: AccountType,
     storage_type: AccountStorageType,
-    code_root: Digest,
+    code_commitment: Digest,
     storage_root: Digest,
 ) -> Result<Word, AccountError> {
     let thread_count = thread::available_parallelism().map_or(1, |v| v.get());
@@ -43,7 +43,7 @@ pub fn get_account_seed(
                 init_seed,
                 account_type,
                 storage_type,
-                code_root,
+                code_commitment,
                 storage_root,
             )
         });
@@ -73,7 +73,7 @@ pub fn get_account_seed_inner(
     init_seed: [u8; 32],
     account_type: AccountType,
     storage_type: AccountStorageType,
-    code_root: Digest,
+    code_commitment: Digest,
     storage_root: Digest,
 ) {
     let init_seed: Vec<[u8; 8]> =
@@ -84,7 +84,7 @@ pub fn get_account_seed_inner(
         Felt::new(u64::from_le_bytes(init_seed[2])),
         Felt::new(u64::from_le_bytes(init_seed[3])),
     ];
-    let mut current_digest = compute_digest(current_seed, code_root, storage_root);
+    let mut current_digest = compute_digest(current_seed, code_commitment, storage_root);
 
     #[cfg(feature = "log")]
     let mut log = log::Log::start(current_digest, current_seed, account_type, storage_type);
@@ -116,7 +116,7 @@ pub fn get_account_seed_inner(
             }
         }
         current_seed = current_digest.into();
-        current_digest = compute_digest(current_seed, code_root, storage_root);
+        current_digest = compute_digest(current_seed, code_commitment, storage_root);
     }
 }
 
@@ -125,10 +125,10 @@ pub fn get_account_seed(
     init_seed: [u8; 32],
     account_type: AccountType,
     storage_type: AccountStorageType,
-    code_root: Digest,
+    code_commitment: Digest,
     storage_root: Digest,
 ) -> Result<Word, AccountError> {
-    get_account_seed_single(init_seed, account_type, storage_type, code_root, storage_root)
+    get_account_seed_single(init_seed, account_type, storage_type, code_commitment, storage_root)
 }
 
 /// Finds and returns a seed suitable for creating an account ID for the specified account type
@@ -137,7 +137,7 @@ pub fn get_account_seed_single(
     init_seed: [u8; 32],
     account_type: AccountType,
     storage_type: AccountStorageType,
-    code_root: Digest,
+    code_commitment: Digest,
     storage_root: Digest,
 ) -> Result<Word, AccountError> {
     let init_seed: Vec<[u8; 8]> =
@@ -148,7 +148,7 @@ pub fn get_account_seed_single(
         Felt::new(u64::from_le_bytes(init_seed[2])),
         Felt::new(u64::from_le_bytes(init_seed[3])),
     ];
-    let mut current_digest = compute_digest(current_seed, code_root, storage_root);
+    let mut current_digest = compute_digest(current_seed, code_commitment, storage_root);
 
     #[cfg(feature = "log")]
     let mut log = log::Log::start(current_digest, current_seed, account_type, storage_type);
@@ -172,7 +172,7 @@ pub fn get_account_seed_single(
             }
         }
         current_seed = current_digest.into();
-        current_digest = compute_digest(current_seed, code_root, storage_root);
+        current_digest = compute_digest(current_seed, code_commitment, storage_root);
     }
 }
 
diff --git a/objects/src/accounts/stub.rs b/objects/src/accounts/stub.rs
index d0c77086f..b2b9bbd58 100644
--- a/objects/src/accounts/stub.rs
+++ b/objects/src/accounts/stub.rs
@@ -11,7 +11,7 @@ use super::{hash_account, Account, AccountId, Digest, Felt};
 /// - nonce: the nonce of the account.
 /// - vault_root: a commitment to the account's vault ([super::AssetVault]).
 /// - storage_root: accounts storage root ([super::AccountStorage]).
-/// - code_root: a commitment to the account's code ([super::AccountCode]).
+/// - code_commitment: a commitment to the account's code ([super::AccountCode]).
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct AccountStub {
@@ -19,7 +19,7 @@ pub struct AccountStub {
     nonce: Felt,
     vault_root: Digest,
     storage_root: Digest,
-    code_root: Digest,
+    code_commitment: Digest,
 }
 
 impl AccountStub {
@@ -31,14 +31,14 @@ impl AccountStub {
         nonce: Felt,
         vault_root: Digest,
         storage_root: Digest,
-        code_root: Digest,
+        code_commitment: Digest,
     ) -> Self {
         Self {
             id,
             nonce,
             vault_root,
             storage_root,
-            code_root,
+            code_commitment,
         }
     }
 
@@ -46,10 +46,10 @@ impl AccountStub {
     // --------------------------------------------------------------------------------------------
     /// Returns hash of this account.
     ///
-    /// Hash of an account is computed as hash(id, nonce, vault_root, storage_root, code_root).
+    /// Hash of an account is computed as hash(id, nonce, vault_root, storage_root, code_commitment).
     /// Computing the account hash requires 2 permutations of the hash function.
     pub fn hash(&self) -> Digest {
-        hash_account(self.id, self.nonce, self.vault_root, self.storage_root, self.code_root)
+        hash_account(self.id, self.nonce, self.vault_root, self.storage_root, self.code_commitment)
     }
 
     /// Returns the id of this account.
@@ -72,9 +72,9 @@ impl AccountStub {
         self.storage_root
     }
 
-    /// Returns the code root of this account.
-    pub fn code_root(&self) -> Digest {
-        self.code_root
+    /// Returns the code commitment of this account.
+    pub fn code_commitment(&self) -> Digest {
+        self.code_commitment
     }
 }
 
@@ -91,7 +91,7 @@ impl From<&Account> for AccountStub {
             nonce: account.nonce(),
             vault_root: account.vault().commitment(),
             storage_root: account.storage().root(),
-            code_root: account.code().root(),
+            code_commitment: account.code().commitment(),
         }
     }
 }
diff --git a/objects/src/errors.rs b/objects/src/errors.rs
index 830bc1a51..15fb20871 100644
--- a/objects/src/errors.rs
+++ b/objects/src/errors.rs
@@ -24,6 +24,8 @@ pub enum AccountError {
     AccountCodeAssemblerError(AssemblyError),
     AccountCodeNoProcedures,
     AccountCodeTooManyProcedures { max: usize, actual: usize },
+    AccountCodeProcedureInvalidStorageOffset,
+    AccountCodeProcedureInvalidPadding,
     AccountIdInvalidFieldElement(String),
     AccountIdTooFewOnes(u32, u32),
     AssetVaultUpdateError(AssetVaultError),
diff --git a/objects/src/testing/account_code.rs b/objects/src/testing/account_code.rs
index b0d50bb2f..1e7f83cbf 100644
--- a/objects/src/testing/account_code.rs
+++ b/objects/src/testing/account_code.rs
@@ -5,19 +5,18 @@ use crate::accounts::AccountCode;
 // The MAST root of the default account's interface. Use these constants to interact with the
 // account's procedures.
 const MASTS: [&str; 11] = [
-    "0xbb58a032a1c1989079dcc73c279d69dcdf41dd7ee923d99dc3f86011663ec167",
-    "0x549d264f00f1a6e90d47284e99eab6d0f93a3d41bb5324743607b6902978a809",
-    "0x704ed1af80a3dae74cd4aabeb4c217924813c42334c2695a74e2702af80a4a35",
-    "0xc25558f483c13aa5be77de4b0987de6a3fab303146fe2fd8ab68b6be8fdcfe76",
-    "0x5dc65ccf6d32880a8eb47fab75b65d926b701ed80220fe5e88152efffcd656ad",
-    "0x73c14f65d2bab6f52eafc4397e104b3ab22a470f6b5cbc86d4aa4d3978c8b7d4",
-    "0x55036198d82d2af653935226c644427162f12e2a2c6b3baf007c9c6f47462872",
-    "0xf484a84dad7f82e8eb1d5190b43243d02d9508437ff97522e14ebf9899758faa",
-    "0xf17acfc7d1eff3ecadd7a17b6d91ff01af638aa9439d6c8603c55648328702ae",
+    "0xe3c24a1109379344874ac5dec91a6311e5563d0194ded29b44ed71535e78b34a",
+    "0x52fd1b2cdbffd91778bc4c31ff939a03c8921461a628bdd91fe3e0a1d3be2b50",
+    "0x28c514e509fc044a2ea6cddbab0abf2b5fa589d5c91978ae9c935ab40e6ec402",
+    "0xa61cdf8c75943d293ffcfca73ea07a6639dad1820d64586a2a292bb9f80a4296",
+    "0x6877f03ef52e490f7c9e41b297fb79bb78075ff28c6e018aaa1ee30f73e7ea4b",
+    "0x24e0a1587d4d1ddff74313518f5187f6042ffbe8f2ddc97d367a5c3da4b17d82",
+    "0x967eedbfee4d8719a253f9e032d25e95890229719404a36d65097e3ad6bd3677",
+    "0xf5b4e6d17ccde492c051e55bd6a5756974ce203c225ad5af0fc80322c6e5a6b5",
+    "0xcd34115714cdcda24f1d6968cbfb67b8b51c1751a2e25e9d6b4e18c35323e5ba",
     "0xff06b90f849c4b262cbfbea67042c4ea017ea0e9c558848a951d44b23370bec5",
     "0x8ef0092134469a1330e3c468f57c7f085ce611645d09cc7516c786fefc71d794",
 ];
-
 pub const ACCOUNT_SEND_ASSET_MAST_ROOT: &str = MASTS[1];
 pub const ACCOUNT_INCR_NONCE_MAST_ROOT: &str = MASTS[2];
 pub const ACCOUNT_SET_ITEM_MAST_ROOT: &str = MASTS[3];
@@ -102,7 +101,7 @@ impl AccountCode {
         # acct proc 5
         export.set_code
             padw swapw
-            # => [CODE_ROOT, 0, 0, 0, 0]
+            # => [CODE_COMMITMENT, 0, 0, 0, 0]
 
             exec.account::set_code
             # => [0, 0, 0, 0]
@@ -154,17 +153,17 @@ impl AccountCode {
         // Comparing all the values together, in case multiple of them change, a single test run will
         // detect it.
         let current = [
-            code.procedures()[0].to_hex(),
-            code.procedures()[1].to_hex(),
-            code.procedures()[2].to_hex(),
-            code.procedures()[3].to_hex(),
-            code.procedures()[4].to_hex(),
-            code.procedures()[5].to_hex(),
-            code.procedures()[6].to_hex(),
-            code.procedures()[7].to_hex(),
-            code.procedures()[8].to_hex(),
-            code.procedures()[9].to_hex(),
-            code.procedures()[10].to_hex(),
+            code.procedures()[0].mast_root().to_hex(),
+            code.procedures()[1].mast_root().to_hex(),
+            code.procedures()[2].mast_root().to_hex(),
+            code.procedures()[3].mast_root().to_hex(),
+            code.procedures()[4].mast_root().to_hex(),
+            code.procedures()[5].mast_root().to_hex(),
+            code.procedures()[6].mast_root().to_hex(),
+            code.procedures()[7].mast_root().to_hex(),
+            code.procedures()[8].mast_root().to_hex(),
+            code.procedures()[9].mast_root().to_hex(),
+            code.procedures()[10].mast_root().to_hex(),
         ];
         assert!(current == MASTS, "const MASTS: [&str; 11] = {:?};", current);
 
diff --git a/objects/src/testing/account_id.rs b/objects/src/testing/account_id.rs
index 2534d1a6e..a4d4ebad8 100644
--- a/objects/src/testing/account_id.rs
+++ b/objects/src/testing/account_id.rs
@@ -54,7 +54,7 @@ impl<T: Rng> AccountIdBuilder<T> {
         &mut self,
         assembler: &Assembler,
     ) -> Result<(AccountId, Word), AccountBuilderError> {
-        let (seed, code_root) = account_id_build_details(
+        let (seed, code_commitment) = account_id_build_details(
             &mut self.rng,
             &self.code,
             self.account_type,
@@ -63,7 +63,7 @@ impl<T: Rng> AccountIdBuilder<T> {
             assembler,
         )?;
 
-        let account_id = AccountId::new(seed, code_root, self.storage_root)
+        let account_id = AccountId::new(seed, code_commitment, self.storage_root)
             .map_err(AccountBuilderError::AccountError)?;
 
         Ok((account_id, seed))
@@ -76,9 +76,9 @@ impl<T: Rng> AccountIdBuilder<T> {
     ) -> Result<AccountId, AccountBuilderError> {
         let code = str_to_account_code(&self.code, assembler)
             .map_err(AccountBuilderError::AccountError)?;
-        let code_root = code.root();
+        let code_commitment = code.commitment();
 
-        let account_id = AccountId::new(seed, code_root, self.storage_root)
+        let account_id = AccountId::new(seed, code_commitment, self.storage_root)
             .map_err(AccountBuilderError::AccountError)?;
 
         if account_id.account_type() != self.account_type {
@@ -96,7 +96,7 @@ impl<T: Rng> AccountIdBuilder<T> {
 // UTILS
 // ================================================================================================
 
-/// Returns the account's seed and code root.
+/// Returns the account's seed and code commitment.
 ///
 /// This compiles `code` and performs the proof-of-work to find a valid seed.
 pub fn account_id_build_details<T: Rng>(
@@ -109,12 +109,17 @@ pub fn account_id_build_details<T: Rng>(
 ) -> Result<(Word, Digest), AccountBuilderError> {
     let init_seed: [u8; 32] = rng.gen();
     let code = str_to_account_code(code, assembler).map_err(AccountBuilderError::AccountError)?;
-    let code_root = code.root();
-    let seed =
-        AccountId::get_account_seed(init_seed, account_type, storage_type, code_root, storage_root)
-            .map_err(AccountBuilderError::AccountError)?;
-
-    Ok((seed, code_root))
+    let code_commitment = code.commitment();
+    let seed = AccountId::get_account_seed(
+        init_seed,
+        account_type,
+        storage_type,
+        code_commitment,
+        storage_root,
+    )
+    .map_err(AccountBuilderError::AccountError)?;
+
+    Ok((seed, code_commitment))
 }
 
 pub fn str_to_account_code(
diff --git a/objects/src/testing/storage.rs b/objects/src/testing/storage.rs
index 18302fbe7..82e7dd72f 100644
--- a/objects/src/testing/storage.rs
+++ b/objects/src/testing/storage.rs
@@ -202,12 +202,13 @@ pub fn generate_account_seed(
         init_seed,
         account_type,
         AccountStorageType::OnChain,
-        account.code().root(),
+        account.code().commitment(),
         account.storage().root(),
     )
     .unwrap();
 
-    let account_id = AccountId::new(seed, account.code().root(), account.storage().root()).unwrap();
+    let account_id =
+        AccountId::new(seed, account.code().commitment(), account.storage().root()).unwrap();
 
     (account_id, seed)
 }
diff --git a/objects/src/transaction/inputs.rs b/objects/src/transaction/inputs.rs
index 728813d6c..b50e5e4ae 100644
--- a/objects/src/transaction/inputs.rs
+++ b/objects/src/transaction/inputs.rs
@@ -448,8 +448,9 @@ pub fn validate_account_seed(
 ) -> Result<(), TransactionInputError> {
     match (account.is_new(), account_seed) {
         (true, Some(seed)) => {
-            let account_id = AccountId::new(seed, account.code().root(), account.storage().root())
-                .map_err(TransactionInputError::InvalidAccountSeed)?;
+            let account_id =
+                AccountId::new(seed, account.code().commitment(), account.storage().root())
+                    .map_err(TransactionInputError::InvalidAccountSeed)?;
             if account_id != account.id() {
                 return Err(TransactionInputError::InconsistentAccountSeed {
                     expected: account.id(),