AccountCode refactor from MerkleTree to Sequential hash for offset based storage access

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)
 

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(),

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

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]

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]
 

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