feat(agglayer): make bridge network ID a deployment setting (#3062)

* feat(agglayer): make bridge network ID a deployment setting

The bridge's AggLayer network ID was hardcoded as the MASM constant
MIDEN_NETWORK_ID and compiled directly into the bridge contract, baking
it into the bridge code commitment. This forced testnet/mainnet, which
may use different network IDs, to ship different bridge binaries.

Store the network ID in the bridge account instead:

- Add a `network_id` value storage slot (`agglayer::bridge::network_id`),
  written once at account creation.
- `bridge_in`/`bridge_out` read it via a new `bridge_config::load_network_id`
  helper instead of `push.MIDEN_NETWORK_ID`, so the bridge code commitment
  is identical across all networks.
- Require `network_id` in `AggLayerBridge::new` and
  `create_(existing_)bridge_account`; add an `AggLayerBridge::network_id`
  reader and `network_id_slot_name` accessor.
- Remove the hardcoded `MIDEN_NETWORK_ID` constant entirely (MASM
  `constants.masm` and its build.rs parsing). Tests keep a fixture-only
  constant matching the bundled Solidity claim vectors.

The ID is never mutated by any bridge procedure, so it is effectively
immutable for the life of the account. Adds bridge-in and bridge-out tests
proving a bridge configured with a non-default network ID enforces it.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Apply suggestions from code review

Co-authored-by: Marti <marcin.gorny.94@protonmail.com>

* fix: remove unused AggLayerBridge import in bridge_in test

The top-level import is shadowed by a function-local `use` in
test_bridge_in_claim_to_p2id, so clippy flags it as unused with
-D warnings.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude (Opus) <noreply@anthropic.com>

Author: mmagician

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v0.16.0 (TBD)
+
+- [BREAKING] Changed AggLayerBridge to store its AggLayer network ID in account storage ([#3062](https://github.com/0xMiden/protocol/pull/3062)).
+
 ## v0.15.2 (2026-06-05)
 
 - [BREAKING] `AuthNetworkAccount` now gates transaction scripts with a root allowlist instead of banning them outright, enabling network accounts to run approved tx scripts such as setting the expiration delta ([#3028](https://github.com/0xMiden/protocol/pull/3028)).

bin/bench-transaction/src/context_setups.rs

@@ -26,6 +26,10 @@ use miden_standards::note::StandardNote;
 use miden_testing::{Auth, MockChain, TransactionContext};
 use rand::Rng;
 
+/// AggLayer network ID encoded in the bundled claim test vectors. Bridges in these benchmark
+/// setups are created with this value so vector-based claims validate against the configured ID.
+const MIDEN_NETWORK_ID: u32 = 77;
+
 // P2ID NOTE SETUPS
 // ================================================================================================
 
@@ -189,8 +193,12 @@ pub async fn tx_consume_claim_note(data_source: ClaimDataSource) -> Result<Trans
 
     // CREATE BRIDGE ACCOUNT
     let bridge_seed = builder.rng_mut().draw_word();
-    let bridge_account =
-        create_existing_bridge_account(bridge_seed, bridge_admin.id(), ger_manager.id());
+    let bridge_account = create_existing_bridge_account(
+        bridge_seed,
+        bridge_admin.id(),
+        ger_manager.id(),
+        MIDEN_NETWORK_ID,
+    );
     builder.add_account(bridge_account.clone())?;
 
     // GET CLAIM DATA FROM JSON
@@ -402,6 +410,7 @@ pub async fn tx_consume_b2agg_note(pre_populate_leaves: Option<u32>) -> Result<T
         builder.rng_mut().draw_word(),
         bridge_admin.id(),
         ger_manager.id(),
+        MIDEN_NETWORK_ID,
     );
 
     // Pre-populate frontier before adding the account to the mock chain

crates/miden-agglayer/SPEC.md

@@ -93,7 +93,7 @@ The `CLAIM` note is consumed by the bridge account:
      `P2ID` note targeted at the recipient directly. The asset must have been previously
      locked into the bridge by a prior bridge-out for the same token.
 
-Inside `bridge_in::claim`, immediately after proof and leaf data are piped into memory, the bridge asserts the leaf's `destination_network` equals the global MASM constant `MIDEN_NETWORK_ID` in `asm/agglayer/common/constants.masm` (after `swap_u32_bytes` on the LE-packed memory limb). The same value is exposed to Rust as `AggLayerBridge::MIDEN_NETWORK_ID`, matching Solidity test vectors.
+Inside `bridge_in::claim`, immediately after proof and leaf data are piped into memory, the bridge asserts the leaf's `destination_network` equals the bridge's configured network ID (after `swap_u32_bytes` on the LE-packed memory limb). The network ID is a deployment setting passed to `create_bridge_account` and stored in the `agglayer::bridge::network_id` slot; `bridge_config::load_network_id` reads it at runtime. It is set once at account creation and never mutated.
 This mirrors Solidity `claimAsset` destination-network checks.
 
 TODO: The leaf type field is not validated to be `LEAF_TYPE_ASSET` (0)
@@ -259,14 +259,14 @@ in the map the procedure panics with `ERR_GER_ALREADY_REGISTERED`.
 | **Inputs** | `[PROOF_DATA_KEY, LEAF_DATA_KEY, faucet_mint_amount, pad(7)]` on the operand stack; proof data and leaf data in the advice map keyed by `PROOF_DATA_KEY` and `LEAF_DATA_KEY` respectively |
 | **Outputs** | `[pad(16)]` |
 | **Context** | Consuming a `CLAIM` note on the bridge account |
-| **Panics** | Leaf `destination_network` does not match `agglayer::common::constants::MIDEN_NETWORK_ID`; invalid leaf type; GER not known; global index invalid; Merkle proof verification failed; (origin token address, origin network) pair not in token registry; claim already spent; amount conversion mismatch |
+| **Panics** | Leaf `destination_network` does not match the bridge's configured network ID; invalid leaf type; GER not known; global index invalid; Merkle proof verification failed; (origin token address, origin network) pair not in token registry; claim already spent; amount conversion mismatch |
 
 Validates a bridge-in claim and creates a MINT note targeting the faucet:
 
 1. Pipes proof data and leaf data from the advice map into memory, verifying preimage
-   integrity, then asserts the leaf's `destination_network` matches the global
-   `MIDEN_NETWORK_ID` constant (`asm/agglayer/common/constants.masm`) after `swap_u32_bytes` on
-   the LE-packed limb (same convention as other AggLayer bridge-in u32 felts in memory).
+   integrity, then asserts the leaf's `destination_network` matches the bridge's configured
+   network ID (read from the `agglayer::bridge::network_id` storage slot) after `swap_u32_bytes`
+   on the LE-packed limb (same convention as other AggLayer bridge-in u32 felts in memory).
 2. Extracts the destination account ID from the leaf data's destination address
    (via `eth_address::to_account_id`).
 3. Validates the Merkle proof via `verify_leaf_bridge`: computes the leaf
@@ -540,8 +540,8 @@ The storage is divided into three logical regions: proof data (felts 0-535), lea
    advice map as two keyed entries (`PROOF_DATA_KEY`, `LEAF_DATA_KEY`).
 4. The `miden_claim_amount` is read from memory.
 5. `bridge_in::claim` is called with `[PROOF_DATA_KEY, LEAF_DATA_KEY, miden_claim_amount]`
-   on the stack. The bridge asserts the leaf's `destination_network` matches the global
-   `MIDEN_NETWORK_ID` MASM constant, validates the proof, checks the claim nullifier, looks up the faucet via the token
+   on the stack. The bridge asserts the leaf's `destination_network` matches the bridge's
+   configured network ID, validates the proof, checks the claim nullifier, looks up the faucet via the token
    registry, verifies the amount conversion, then builds a MINT output note targeting the faucet.
 
 #### Permissions

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

@@ -26,6 +26,7 @@ const GER_MAP_STORAGE_SLOT = word("agglayer::bridge::ger_map")
 const FAUCET_REGISTRY_MAP_SLOT = word("agglayer::bridge::faucet_registry_map")
 const TOKEN_REGISTRY_MAP_SLOT = word("agglayer::bridge::token_registry_map")
 const FAUCET_METADATA_MAP_SLOT = word("agglayer::bridge::faucet_metadata_map")
+const NETWORK_ID_SLOT = word("agglayer::bridge::network_id")
 
 # Flags
 const GER_KNOWN_FLAG = [1, 0, 0, 0]
@@ -541,3 +542,27 @@ proc assert_sender_is_ger_manager
     assert.err=ERR_SENDER_NOT_GER_MANAGER
     # => [pad(16)]
 end
+
+#! Returns the AggLayer network ID assigned to this bridge.
+#!
+#! The network ID is written to NETWORK_ID_SLOT once at account creation and is never mutated by
+#! any bridge procedure, so it is effectively immutable for the lifetime of the account. It
+#! identifies this Miden chain within the AggLayer and may differ between deployments (e.g. testnet
+#! vs mainnet).
+#!
+#! Inputs:  []
+#! Outputs: [network_id]
+#!
+#! Where:
+#! - network_id is the u32 AggLayer network ID of this bridge.
+#!
+#! Invocation: exec
+pub proc load_network_id
+    push.NETWORK_ID_SLOT[0..2]
+    exec.active_account::get_item
+    # => [network_id, 0, 0, 0]
+
+    # discard the three padding zeros, keeping only the network ID
+    movdn.3 drop drop drop
+    # => [network_id]
+end

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

@@ -1,7 +1,6 @@
 use agglayer::bridge::bridge_config
 use agglayer::bridge::bridge_in_output
 use agglayer::bridge::leaf_utils
-use agglayer::common::constants::MIDEN_NETWORK_ID
 use agglayer::common::utils
 use agglayer::common::asset_conversion
 use agglayer::common::eth_address
@@ -166,7 +165,7 @@ const CLAIM_DEST_ID_SUFFIX_LOCAL = 1
 #!
 #! Panics if:
 #! - the leaf type is not 0 (not an asset claim).
-#! - the leaf destination network does not match the global `MIDEN_NETWORK_ID` constant.
+#! - the leaf destination network does not match the bridge's configured network ID.
 #! - the Merkle proof validation fails.
 #! - the (origin_token_address, origin_network) pair is not registered in the bridge's token registry.
 #!
@@ -932,30 +931,32 @@ proc store_cgi_chain_hash
     # => []
 end
 
-#! Asserts the claim leaf's `destination_network` matches the global `MIDEN_NETWORK_ID`.
+#! Asserts the claim leaf's `destination_network` matches the bridge's configured network ID.
 #!
 #! `claim_batch_pipe_double_words` stores leaf felts as LE-packed u32 limbs. `swap_u32_bytes`
-#! converts the loaded limb to the canonical u32 value so it can be compared to `MIDEN_NETWORK_ID`
-#! from `agglayer::common::constants`.
+#! converts the loaded limb to the canonical u32 value so it can be compared to the network ID
+#! read from the bridge's storage via `bridge_config::load_network_id`.
 #!
 #! Inputs:  []
 #! Outputs: []
 #!
 #! Panics if:
-#! - the leaf destination network does not match the Miden AggLayer network ID constant.
+#! - the leaf destination network does not match the bridge's configured network ID.
 #!
 #! Invocation: exec
 proc assert_claim_leaf_destination_network
     # load the destination network ID onto the stack
     mem_load.DESTINATION_NETWORK_ID_MEM_ADDR
     # => [destination_network_id_le]
 
-    # change the endianness to BE to compare it with the Miden network ID
+    # change the endianness to BE to compare it with the network ID
     exec.utils::swap_u32_bytes
     # => [destination_network_id_be]
 
-    # assert that the destination network ID matches the Miden network ID
-    push.MIDEN_NETWORK_ID
+    # assert that the destination network ID matches the bridge's configured network ID
+    exec.bridge_config::load_network_id
+    # => [network_id, destination_network_id_be]
+
     assert_eq.err=ERR_CLAIM_LEAF_DESTINATION_NETWORK_MISMATCH
     # => []
 end

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

@@ -10,7 +10,6 @@ use miden::standards::note::execution_hint::ALWAYS
 use miden::protocol::types::MemoryAddress
 use miden::protocol::output_note
 use miden::core::crypto::hashes::poseidon2
-use agglayer::common::constants::MIDEN_NETWORK_ID
 use agglayer::common::utils
 use agglayer::common::asset_conversion
 use agglayer::bridge::bridge_config
@@ -246,23 +245,29 @@ end
 # HELPER PROCEDURES
 # =================================================================================================
 
-#! Asserts that the bridge-out destination network ID is not equal to the Miden's AggLayer network
-#! ID.
+#! Asserts that the bridge-out destination network ID is not equal to the bridge's configured
+#! network ID.
 #!
 #! Inputs:  [dest_network_id]
 #! Outputs: []
 #!
+#! Where:
+#! - dest_network_id is the LE-packed u32 destination network ID of the B2AGG note.
+#!
 #! Panics if:
-#! - the destination network ID equals `MIDEN_NETWORK_ID`.
+#! - the destination network ID equals the bridge's configured network ID.
 #!
 #! Invocation: exec
 proc assert_destination_id_not_miden_id
-    # change the endianness to BE to compare it with the Miden network ID
+    # change the endianness to BE to compare it with the network ID
     exec.utils::swap_u32_bytes
     # => [destination_network_id_be]
 
-    # assert that the destination network ID is not equal to the Miden network ID
-    push.MIDEN_NETWORK_ID neq assert.err=ERR_B2AGG_DESTINATION_NETWORK_IS_MIDEN
+    # assert that the destination network ID is not equal to the bridge's configured network ID
+    exec.bridge_config::load_network_id
+    # => [network_id, destination_network_id_be]
+
+    neq assert.err=ERR_B2AGG_DESTINATION_NETWORK_IS_MIDEN
     # => []
 end
 

crates/miden-agglayer/asm/agglayer/common/constants.masm

@@ -1,4 +1,4 @@
-use std::collections::{BTreeSet, HashSet};
+use std::collections::BTreeSet;
 use std::env;
 use std::fmt::Write;
 use std::path::Path;
@@ -21,7 +21,6 @@ use miden_standards::account::policies::{
     TokenPolicyManager,
     TransferPolicy,
 };
-use regex::Regex;
 
 // CONSTANTS
 // ================================================================================================
@@ -31,7 +30,6 @@ const ASM_DIR: &str = "asm";
 const ASM_NOTE_SCRIPTS_DIR: &str = "note_scripts";
 const ASM_AGGLAYER_DIR: &str = "agglayer";
 const ASM_AGGLAYER_BRIDGE_DIR: &str = "agglayer/bridge";
-const ASM_AGGLAYER_CONSTANTS_MASM: &str = "agglayer/common/constants.masm";
 const ASM_COMPONENTS_DIR: &str = "components";
 
 const AGGLAYER_ERRORS_RS_FILE: &str = "agglayer_errors.rs";
@@ -86,12 +84,7 @@ fn main() -> Result<()> {
 
     // generate agglayer specific constants
     let constants_out_path = Path::new(&build_dir).join(AGGLAYER_GLOBAL_CONSTANTS_FILE_NAME);
-    let agglayer_constants_masm_path = crate_path.join(ASM_DIR).join(ASM_AGGLAYER_CONSTANTS_MASM);
-    generate_agglayer_constants(
-        constants_out_path,
-        component_libraries,
-        &agglayer_constants_masm_path,
-    )?;
+    generate_agglayer_constants(constants_out_path, component_libraries)?;
 
     generate_error_constants(&source_dir, &build_dir)?;
 
@@ -217,78 +210,14 @@ fn compile_account_components(
 // GENERATE AGGLAYER CONSTANTS
 // ================================================================================================
 
-/// Parses every decimal `u32` constant from `asm/agglayer/common/constants.masm`.
-///
-/// Recognized lines (whitespace-flexible, one definition per line, `#` comments ignored by the
-/// regex):
-///
-/// ```text
-/// const SOME_NAME = 123
-/// ```
-///
-/// Each match is emitted to `agglayer_constants.rs` as `pub const SOME_NAME: u32`.
-/// Duplicate `const` names in the same file are a build error. Non-decimal values (e.g. `word(...)`
-/// or array literals) are not parsed here; add support in this function when needed.
-fn parse_numeric_constants_from_constants_masm(masm_path: &Path) -> Result<Vec<(String, u32)>> {
-    // Read the full `constants.masm` text; parsing is line-based so we need the whole file.
-    let contents = fs::read_to_string(masm_path)
-        .into_diagnostic()
-        .wrap_err_with(|| format!("failed to read {}", masm_path.display()))?;
-
-    // One line per match: optional leading space, optional `pub` visibility, `const`, identifier
-    // (no leading digit), `=`, decimal digits only. `(?m)^` makes `^` match after newlines so we
-    // skip comment-only lines.
-    let re = Regex::new(r"(?m)^\s*(?:pub\s+)?const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(\d+)\s*$")
-        .expect("constants.masm parse regex should compile");
-
-    // `out` preserves declaration order; `seen` rejects duplicate const names in the same file.
-    let mut out = Vec::new();
-    let mut seen = HashSet::new();
-
-    for caps in re.captures_iter(&contents) {
-        let name = caps.get(1).expect("group 1").as_str();
-
-        // Require each identifier at most once so generated Rust names are unique.
-        if !seen.insert(name.to_string()) {
-            return Err(Report::msg(format!(
-                "duplicate `const {name}` in {}",
-                masm_path.display()
-            )));
-        }
-
-        // Right-hand side must fit `u32` (same range we emit in Rust).
-        let raw = caps.get(2).expect("group 2").as_str();
-        let value = raw.parse::<u32>().map_err(|_| {
-            Report::msg(format!(
-                "`const {name}` value `{raw}` is not a valid u32 in {}",
-                masm_path.display()
-            ))
-        })?;
-
-        out.push((name.to_string(), value));
-    }
-
-    // Empty match set is almost certainly a misconfigured or mistyped `constants.masm`.
-    if out.is_empty() {
-        return Err(Report::msg(format!(
-            "{} does not contain any constants to parse",
-            masm_path.display()
-        )));
-    }
-
-    Ok(out)
-}
-
 /// Generates a Rust file containing AggLayer specific constants.
 ///
 /// This file contains:
-/// - All the constants listed in the `constants.masm` file.
 /// - AggLayer Bridge code commitment.
 /// - AggLayer Faucet code commitment.
 fn generate_agglayer_constants(
     target_file: impl AsRef<Path>,
     component_libraries: Vec<(String, Library)>,
-    constants_masm_path: &Path,
 ) -> Result<()> {
     let mut file_contents = String::new();
 
@@ -306,11 +235,6 @@ fn generate_agglayer_constants(
     )
     .unwrap();
 
-    let masm_constants = parse_numeric_constants_from_constants_masm(constants_masm_path)?;
-    for (name, value) in &masm_constants {
-        writeln!(file_contents, "pub const {name}: u32 = {value};\n").unwrap();
-    }
-
     // Create a dummy metadata to be able to create components. We only interested in the resulting
     // code commitment, so it doesn't matter what does this metadata holds.
     let dummy_metadata = AccountComponentMetadata::new("dummy");