feat(AggLayer bridge-out e2e #2): store Local Exit Tree in AggLayerBridge contract and update it upon B2AGG consumption

crates/miden-agglayer/asm/bridge/bridge_out.masm

@@ -1,13 +1,17 @@
 use miden::protocol::active_note
+use miden::protocol::active_account
+use miden::protocol::native_account
 use miden::protocol::note
 use miden::standards::note_tag
+use miden::standards::data_structures::double_word_array
 use miden::protocol::output_note
 use miden::core::crypto::hashes::keccak256
 use miden::core::crypto::hashes::rpo256
 use miden::core::word
 use miden::agglayer::utils
 use miden::agglayer::asset_conversion
 use miden::agglayer::crypto_utils
+use miden::agglayer::mmr_frontier32_keccak
 
 
 # TYPE ALIASES
@@ -21,6 +25,11 @@ type MemoryAddress = u32
 const BURN_ASSET_MEM_PTR=24
 const LEAF_DATA_START_PTR=44
 
+# Memory pointer for loading the LET (Local Exit Tree) frontier into memory.
+# The memory layout at this address matches what append_and_update_frontier expects:
+# [num_leaves, 0, 0, 0, [[FRONTIER_NODE_LO, FRONTIER_NODE_HI]; 32]]
+const LET_FRONTIER_MEM_PTR=100
+
 const LEAF_TYPE_OFFSET=0
 const ORIGIN_NETWORK_OFFSET=1
 const ORIGIN_TOKEN_ADDRESS_OFFSET=2
@@ -33,7 +42,13 @@ const PADDING_OFFSET=29
 const PUBLIC_NOTE=1
 const BURN_NOTE_NUM_STORAGE_ITEMS=0
 
+# Storage slot constants for the LET (Local Exit Tree).
+# The frontier is stored as a double-word array in a map slot.
+# The root and num_leaves are stored in separate value slots.
 const LOCAL_EXIT_TREE_SLOT=word("miden::agglayer::let")
+const LET_ROOT_LO_SLOT=word("miden::agglayer::let::root_lo")
+const LET_ROOT_HI_SLOT=word("miden::agglayer::let::root_hi")
+const LET_NUM_LEAVES_SLOT=word("miden::agglayer::let::num_leaves")
 
 const LEAF_TYPE_ASSET=0
 # TBD once we have an AggLayer-specific network ID
@@ -170,10 +185,140 @@ end
 #! Invocation: exec
 proc add_leaf_bridge(leaf_data_start_ptr: MemoryAddress)
     exec.crypto_utils::compute_leaf_value
-    # => [LEAF_VALUE[8]]
+    # => [LEAF_VALUE_LO, LEAF_VALUE_HI]
+
+    # Load the LET frontier from storage into memory at LET_FRONTIER_MEM_PTR
+    exec.load_let_frontier_to_memory
+    # => [LEAF_VALUE_LO, LEAF_VALUE_HI]
+
+    # Push frontier pointer below the leaf value
+    push.LET_FRONTIER_MEM_PTR movdn.8
+    # => [LEAF_VALUE_LO, LEAF_VALUE_HI, let_frontier_ptr]
+
+    # Append the leaf to the frontier and compute the new root
+    exec.mmr_frontier32_keccak::append_and_update_frontier
+    # => [NEW_ROOT_LO, NEW_ROOT_HI, new_leaf_count]
+
+    # Save the root and num_leaves to their value slots
+    exec.save_let_root_and_num_leaves
+    # => []
+
+    # Write the updated frontier from memory back to the map
+    exec.save_let_frontier_to_storage
+    # => []
+end
+
+#! Loads the LET (Local Exit Tree) frontier from account storage into memory.
+#!
+#! The num_leaves is read from its dedicated value slot, and the 32 frontier entries are read
+#! from the LET map slot (double-word array, indices 0..31). The data is placed into memory at
+#! LET_FRONTIER_MEM_PTR, matching the layout expected by append_and_update_frontier:
+#! [num_leaves, 0, 0, 0, [[FRONTIER_NODE_LO, FRONTIER_NODE_HI]; 32]]
+#!
+#! Empty (uninitialized) map entries return zeros, which is the correct initial state for the
+#! frontier when there are no leaves.
+#!
+#! Inputs:  []
+#! Outputs: []
+#!
+#! Invocation: exec
+proc load_let_frontier_to_memory
+    # 1. Load num_leaves from its value slot
+    push.LET_NUM_LEAVES_SLOT[0..2]
+    exec.active_account::get_item
+    # => [num_leaves_word]
+
+    push.LET_FRONTIER_MEM_PTR mem_storew_be dropw
+    # => []
+
+    # 2. Load 32 frontier double-word entries from the map via double_word_array::get
+    push.0
+    # => [h=0]
+
+    repeat.32
+        # => [h]
+
+        # Read frontier[h] as a double word from the map
+        dup push.LOCAL_EXIT_TREE_SLOT[0..2]
+        exec.double_word_array::get
+        # => [VALUE_0, VALUE_1, h]
+
+        # Compute memory address and store the double word
+        dup.8 mul.8 add.LET_FRONTIER_MEM_PTR add.4 movdn.8
+        # => [VALUE_0, VALUE_1, mem_addr, h]
+        exec.utils::mem_store_double_word
+        dropw dropw drop
+        # => [h]
 
-    # TODO: Add LEAF_VALUE to MMR frontier
-    dropw dropw
+        add.1
+        # => [h+1]
+    end
+
+    drop
+    # => []
+end
+
+#! Saves the Local Exit Root and num_leaves to their dedicated value slots.
+#!
+#! Inputs:  [NEW_ROOT_LO, NEW_ROOT_HI, new_leaf_count]
+#! Outputs: []
+#!
+#! Invocation: exec
+proc save_let_root_and_num_leaves
+    # 1. Save root lo word to its value slot
+    push.LET_ROOT_LO_SLOT[0..2]
+    exec.native_account::set_item
+    dropw
+    # => [NEW_ROOT_HI, new_leaf_count]
+
+    # 2. Save root hi word to its value slot
+    push.LET_ROOT_HI_SLOT[0..2]
+    exec.native_account::set_item
+    dropw
+    # => [new_leaf_count]
+
+    # 3. Save new_leaf_count to its value slot as [new_leaf_count, 0, 0, 0]
+    push.0.0.0
+    # => [0, 0, 0, new_leaf_count]
+    push.LET_NUM_LEAVES_SLOT[0..2]
+    exec.native_account::set_item
+    dropw
+    # => []
+end
+
+#! Writes the 32 frontier entries from memory back to the LET map slot.
+#!
+#! Each frontier entry is a double word (Keccak256 digest) stored at
+#! LET_FRONTIER_MEM_PTR + 4 + h * 8, and is written to the map at double_word_array index h.
+#!
+#! Inputs:  []
+#! Outputs: []
+#!
+#! Invocation: exec
+proc save_let_frontier_to_storage
+    push.0
+    # => [h=0]
+
+    repeat.32
+        # => [h]
+
+        # Load frontier[h] double word from memory
+        dup mul.8 add.LET_FRONTIER_MEM_PTR add.4
+        exec.utils::mem_load_double_word
+        # => [VALUE_0, VALUE_1, h]
+
+        # Write it back to the map at index h
+        dup.8 push.LOCAL_EXIT_TREE_SLOT[0..2]
+        exec.double_word_array::set
+        dropw dropw
+        # => [h]
+
+        add.1
+        # => [h+1]
+    end
+
+    drop
+    # => []
 end
 
 #! Writes the destination address to memory.

crates/miden-agglayer/solidity-compat/README.md

@@ -46,5 +46,12 @@ The canonical zeros should match the constants in:
 
 ### MMR Frontier Vectors
 
-The `test_generateVectors` adds leaves `0, 1, 2, ...` (as left-padded 32-byte values)
-and outputs the root after each addition.
+The `test_generateVectors` adds 32 leaves and outputs the root after each addition.
+Each leaf uses:
+
+- `amounts[i] = i + 1`
+- `destination_networks[i]` and `destination_addresses[i]` generated deterministically from
+  a fixed seed in `MMRTestVectors.t.sol`
+
+This gives reproducible "random-looking" destination parameters while keeping vector generation
+stable across machines and reruns.

crates/miden-agglayer/solidity-compat/foundry.lock

@@ -7,5 +7,11 @@
       "name": "v1.14.0",
       "rev": "1801b0541f4fda118a10798fd3486bb7051c5dd6"
     }
+  },
+  "lib/openzeppelin-contracts-upgradeable": {
+    "branch": {
+      "name": "release-v4.9",
+      "rev": "2d081f24cac1a867f6f73d512f2022e1fa987854"
+    }
   }
 }