feat(fast-inbox): same-block L1-to-L2 message consumption for non-first blocks (A-1432)

The non-first tx-carrying block-root variants (block_root, block_root_single_tx) now take
their start L1-to-L2 tree snapshot as a witness input, pinned by block-merge continuity
(right.start_state == left.end_state) to the previous block's end state, and assert the tx
constants carry their own post-bundle root via validate_l1_to_l2_tree_snapshot_in_constants,
exactly like the first-block variants. This lets a public/AVM tx in block N read the messages
block N inserts (same-block consumption) instead of only from block N+1.

Previously the non-first variants read their start snapshot from constants.l1_to_l2_tree_snapshot
and never asserted the post-bundle root, so mid-checkpoint insertions were next-block-visible.

Bit-identical pre-flip: non-first bundles are empty, so post-bundle == start == today's constants
value, and the new assert passes with unchanged values. The tx-less variants (empty-first,
msgs-only) carry no tx constants and already witness their start snapshot, so they are unchanged.

Adds negative nargo tests (a non-first block whose constants snapshot differs from its post-bundle
root must fail) and mirrors the new witness field through stdlib serialization, the Noir ABI
conversion, and the prover-client block-root input builders.

VK/artifact regen, checkpoint-root/block-root Prover.toml sample-input regen, and the generated
noir-protocol-circuits-types (index.ts) regen ride the mainframe/CI flow; they are not regenerated
locally (bb write_vk OOMs on large circuits on dev boxes).

Author: spalladino

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_rollup.nr

@@ -1,8 +1,12 @@
 use crate::{
     abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs},
-    block_root::components::{BlockRollupPublicInputsComposer, validate_previous_rollups},
+    block_root::components::{
+        BlockRollupPublicInputsComposer, validate_l1_to_l2_tree_snapshot_in_constants,
+        validate_previous_rollups,
+    },
 };
 use types::{
+    abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot,
     constants::{
         ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX,
         PUBLIC_TX_BASE_ROLLUP_VK_INDEX, TX_MERGE_ROLLUP_VK_INDEX,
@@ -17,11 +21,15 @@ pub struct BlockRootRollupPrivateInputs {
     pub(crate) previous_rollups: [RollupHonkProofData<TxRollupPublicInputs>; 2],
     // L1-to-L2 message bundle inserted by this block.
     pub(crate) message_bundle: L1ToL2MessageBundle,
+    // The l1-to-l2 tree snapshot this block builds on (the previous block's post-insertion snapshot). It is a witnessed
+    // value, pinned by block-merge continuity (`right.start_state == left.end_state`) to the previous block's end
+    // state; since the checkpoint root forces the leftmost block to be a first-block variant, every non-first block
+    // has a left neighbour that pins it.
+    pub(crate) previous_l1_to_l2: AppendOnlyTreeSnapshot,
     // Message sponge inherited from the previous block. Checked against the previous block's `end_msg_sponge` in the
     // block merge or checkpoint root circuit.
     pub(crate) start_msg_sponge: L1ToL2MessageSponge,
-    // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against the tree snapshot in the
-    // constants, which is where the l1-to-l2 tree stands for this non-first block).
+    // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_l1_to_l2`).
     pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT],
     // Hint for inserting the new block hash to the last archive.
     pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT],
@@ -43,18 +51,29 @@ pub struct BlockRootRollupPrivateInputs {
 ///
 /// VkIndex: BLOCK_ROOT_ROLLUP_VK_INDEX
 pub fn execute(inputs: BlockRootRollupPrivateInputs) -> BlockRollupPublicInputs {
-    validate_previous_rollups(inputs.previous_rollups, ALLOWED_PREVIOUS_VK_INDICES);
-
     let previous_rollups = inputs.previous_rollups.map(|rollup| rollup.public_inputs);
-    // Non-first blocks build on the l1-to-l2 tree snapshot carried in the checkpoint constants.
-    let previous_l1_to_l2 = previous_rollups[0].constants.l1_to_l2_tree_snapshot;
-    BlockRollupPublicInputsComposer::new_from_two_rollups(previous_rollups)
+    // Non-first blocks build on a witnessed start snapshot (pinned by block-merge continuity to the previous block's
+    // end state) rather than the constants value, so this block can append its own bundle and still assert the tx
+    // constants carry the post-bundle snapshot.
+    let mut composer = BlockRollupPublicInputsComposer::new_from_two_rollups(previous_rollups);
+    let new_l1_to_l2 = composer
         .with_message_bundle(
             false,
-            previous_l1_to_l2,
+            inputs.previous_l1_to_l2,
             inputs.start_msg_sponge,
             inputs.message_bundle,
             inputs.l1_to_l2_message_frontier_hint,
         )
-        .finish(inputs.new_archive_sibling_path)
+        .get_new_l1_to_l2();
+
+    validate_previous_rollups(inputs.previous_rollups, ALLOWED_PREVIOUS_VK_INDICES);
+
+    // The tx constants pin the l1-to-l2 snapshot the AVM validates message reads against; asserting it equals this
+    // block's post-bundle root lets this block's txs read the messages this block inserts (same-block consumption).
+    validate_l1_to_l2_tree_snapshot_in_constants(
+        inputs.previous_rollups[0].public_inputs.constants,
+        new_l1_to_l2,
+    );
+
+    composer.finish(inputs.new_archive_sibling_path)
 }

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_rollup.nr

@@ -1,8 +1,12 @@
 use crate::{
     abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs},
-    block_root::components::{BlockRollupPublicInputsComposer, validate_previous_rollups},
+    block_root::components::{
+        BlockRollupPublicInputsComposer, validate_l1_to_l2_tree_snapshot_in_constants,
+        validate_previous_rollups,
+    },
 };
 use types::{
+    abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot,
     constants::{
         ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX,
         PUBLIC_TX_BASE_ROLLUP_VK_INDEX,
@@ -18,11 +22,15 @@ pub struct BlockRootSingleTxRollupPrivateInputs {
     pub(crate) previous_rollup: RollupHonkProofData<TxRollupPublicInputs>,
     // L1-to-L2 message bundle inserted by this block.
     pub(crate) message_bundle: L1ToL2MessageBundle,
+    // The l1-to-l2 tree snapshot this block builds on (the previous block's post-insertion snapshot). It is a witnessed
+    // value, pinned by block-merge continuity (`right.start_state == left.end_state`) to the previous block's end
+    // state; since the checkpoint root forces the leftmost block to be a first-block variant, every non-first block
+    // has a left neighbour that pins it.
+    pub(crate) previous_l1_to_l2: AppendOnlyTreeSnapshot,
     // Message sponge inherited from the previous block. Checked against the previous block's `end_msg_sponge` in the
     // block merge or checkpoint root circuit.
     pub(crate) start_msg_sponge: L1ToL2MessageSponge,
-    // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against the tree snapshot in the
-    // constants, which is where the l1-to-l2 tree stands for this non-first block).
+    // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_l1_to_l2`).
     pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT],
     // Hint for inserting the new block hash to the last archive.
     pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT],
@@ -43,17 +51,30 @@ pub struct BlockRootSingleTxRollupPrivateInputs {
 ///
 /// VkIndex: BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX
 pub fn execute(inputs: BlockRootSingleTxRollupPrivateInputs) -> BlockRollupPublicInputs {
-    validate_previous_rollups([inputs.previous_rollup], ALLOWED_PREVIOUS_VK_INDICES);
-
-    // Non-first blocks build on the l1-to-l2 tree snapshot carried in the checkpoint constants.
-    let previous_l1_to_l2 = inputs.previous_rollup.public_inputs.constants.l1_to_l2_tree_snapshot;
-    BlockRollupPublicInputsComposer::new_from_single_rollup(inputs.previous_rollup.public_inputs)
+    // Non-first blocks build on a witnessed start snapshot (pinned by block-merge continuity to the previous block's
+    // end state) rather than the constants value, so this block can append its own bundle and still assert the tx
+    // constants carry the post-bundle snapshot.
+    let mut composer = BlockRollupPublicInputsComposer::new_from_single_rollup(
+        inputs.previous_rollup.public_inputs,
+    );
+    let new_l1_to_l2 = composer
         .with_message_bundle(
             false,
-            previous_l1_to_l2,
+            inputs.previous_l1_to_l2,
             inputs.start_msg_sponge,
             inputs.message_bundle,
             inputs.l1_to_l2_message_frontier_hint,
         )
-        .finish(inputs.new_archive_sibling_path)
+        .get_new_l1_to_l2();
+
+    validate_previous_rollups([inputs.previous_rollup], ALLOWED_PREVIOUS_VK_INDICES);
+
+    // The tx constants pin the l1-to-l2 snapshot the AVM validates message reads against; asserting it equals this
+    // block's post-bundle root lets this block's txs read the messages this block inserts (same-block consumption).
+    validate_l1_to_l2_tree_snapshot_in_constants(
+        inputs.previous_rollup.public_inputs.constants,
+        new_l1_to_l2,
+    );
+
+    composer.finish(inputs.new_archive_sibling_path)
 }

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr

@@ -133,9 +133,10 @@ impl BlockRollupPublicInputsComposer {
     /// Appends this block's L1-to-L2 message bundle to the tree and absorbs its real messages into the message sponge.
     ///
     /// `previous_l1_to_l2` is the tree snapshot this block builds on: for the first block it is the pre-insertion
-    /// snapshot (hinted, and later checked against the previous checkpoint), for subsequent blocks it is the snapshot
-    /// carried in the constants. `start_msg_sponge` is the sponge inherited from the previous block (empty for the
-    /// first block).
+    /// snapshot (hinted, and later checked against the previous checkpoint), for subsequent blocks it is a witnessed
+    /// snapshot pinned by block-merge continuity to the previous block's end state. Either way, the caller asserts the
+    /// tx constants carry the resulting post-bundle snapshot. `start_msg_sponge` is the sponge inherited from the
+    /// previous block (empty for the first block).
     ///
     /// The tree append and the sponge absorb use different counts transitionally (see `L1ToL2MessageBundle`): the tree
     /// inserts `bundle.num_msgs` leaves (a full padded subtree for a message-bearing block), while the sponge absorbs
@@ -182,8 +183,8 @@ impl BlockRollupPublicInputsComposer {
         *self
     }
 
-    /// The l1-to-l2 tree snapshot after appending this block's bundle. First-block variants check this against the
-    /// snapshot in the tx constants (consumed by the AVM to read new messages).
+    /// The l1-to-l2 tree snapshot after appending this block's bundle. Tx-carrying variants (first and non-first)
+    /// check this against the snapshot in the tx constants (consumed by the AVM to read new messages).
     pub fn get_new_l1_to_l2(self) -> AppendOnlyTreeSnapshot {
         self.new_l1_to_l2
     }

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_root_rollup_inputs_validator.nr

@@ -50,11 +50,11 @@ pub fn validate_previous_rollups<let NumPreviousRollups: u32, let NumVkIndices:
 /// This snapshot is used in the AVM to validate l1-to-l2 message read requests, allowing public functions to
 /// read new messages before they are inserted into the tree in the block root circuit.
 ///
-/// This check is only required for the first block in a checkpoint, where the new l1-to-l2 messages are inserted
-/// into the tree. For subsequent blocks, the value in the constants is simply propagated to the start and end states of
-/// the public inputs. However, the start state of each block must match the end state of the previous block, which is
-/// validated in the block merge or checkpoint root circuit. This ensures that the snapshot used in subsequent blocks
-/// matches the `computed_new_l1_to_l2` from the first block.
+/// Every tx-carrying block-root variant (first and non-first) runs this check against its own post-bundle snapshot, so
+/// each block's txs can read the messages that block inserts (same-block consumption). Non-first variants take their
+/// start snapshot as a witness rather than reading it from the constants; that witness is pinned to the previous
+/// block's end state by the block merge or checkpoint root circuit, so it cannot be forged. (The tx-less variants —
+/// empty-first and msgs-only — carry no tx constants to read against and so skip this check.)
 pub fn validate_l1_to_l2_tree_snapshot_in_constants(
     constants: BlockConstantData,
     computed_new_l1_to_l2: AppendOnlyTreeSnapshot,

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/failures_tests.nr

@@ -160,3 +160,49 @@ fn incorrect_l1_to_l2_tree_next_available_leaf_index__first_single_tx_block() {
 
     builder.execute_and_fail();
 }
+
+// Non-first blocks also insert their own bundle and must pin the post-bundle snapshot in their tx constants, so a
+// non-first block whose constants snapshot differs from its computed post-bundle root must fail (same-block
+// consumption). Both child rollups are tweaked together so the mismatch surfaces here rather than as unequal
+// constants between the two tx rollups.
+#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")]
+fn incorrect_l1_to_l2_tree_root__non_first_block() {
+    let mut builder = TestBuilder::default(false, false);
+
+    // Tweak the root of the l1_to_l2_tree_snapshot in the rollups' constants.
+    builder.left_rollup.constants.l1_to_l2_tree_snapshot.root += 1;
+    builder.right_rollup.constants.l1_to_l2_tree_snapshot.root += 1;
+
+    builder.execute_and_fail();
+}
+
+#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")]
+fn incorrect_l1_to_l2_tree_next_available_leaf_index__non_first_block() {
+    let mut builder = TestBuilder::default(false, false);
+
+    // Tweak the next_available_leaf_index of the l1_to_l2_tree_snapshot in the rollups' constants.
+    builder.left_rollup.constants.l1_to_l2_tree_snapshot.next_available_leaf_index += 1;
+    builder.right_rollup.constants.l1_to_l2_tree_snapshot.next_available_leaf_index += 1;
+
+    builder.execute_and_fail();
+}
+
+#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")]
+fn incorrect_l1_to_l2_tree_root__non_first_single_tx_block() {
+    let mut builder = TestBuilder::default(false, true);
+
+    // Tweak the root of the l1_to_l2_tree_snapshot in the rollup's constants.
+    builder.left_rollup.constants.l1_to_l2_tree_snapshot.root += 1;
+
+    builder.execute_and_fail();
+}
+
+#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")]
+fn incorrect_l1_to_l2_tree_next_available_leaf_index__non_first_single_tx_block() {
+    let mut builder = TestBuilder::default(false, true);
+
+    // Tweak the next_available_leaf_index of the l1_to_l2_tree_snapshot in the rollup's constants.
+    builder.left_rollup.constants.l1_to_l2_tree_snapshot.next_available_leaf_index += 1;
+
+    builder.execute_and_fail();
+}

noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr

@@ -108,13 +108,10 @@ impl TestBuilder {
         let (previous_l1_to_l2, l1_to_l2_messages, l1_to_l2_message_frontier_hint, new_l1_to_l2) =
             fixture_builder.build_l1_to_l2_message_bundle(TEST_NUM_MSGS);
 
-        // The l1-to-l2 tree snapshot carried in the constants is the pre-append snapshot for non-first blocks (the tree
-        // where this block picks up), and the post-append snapshot for first blocks (checked by the circuit against the
-        // computed value).
-        let constants_l1_to_l2 =
-            if is_first_block_root { new_l1_to_l2 } else { previous_l1_to_l2 };
-        left_rollup.constants.l1_to_l2_tree_snapshot = constants_l1_to_l2;
-        right_rollup.constants.l1_to_l2_tree_snapshot = constants_l1_to_l2;
+        // Every tx-carrying block-root variant (first and non-first) asserts the l1-to-l2 tree snapshot carried in the
+        // tx constants equals the post-append snapshot, so its txs read the messages this block inserts.
+        left_rollup.constants.l1_to_l2_tree_snapshot = new_l1_to_l2;
+        right_rollup.constants.l1_to_l2_tree_snapshot = new_l1_to_l2;
 
         // First blocks start the message sponge from empty; non-first blocks inherit a (non-empty) sponge.
         let start_msg_sponge = if is_first_block_root {
@@ -242,6 +239,7 @@ impl TestBuilder {
                 BlockRootSingleTxRollupPrivateInputs {
                     previous_rollup: previous_rollups[0],
                     message_bundle,
+                    previous_l1_to_l2: self.previous_l1_to_l2,
                     start_msg_sponge,
                     l1_to_l2_message_frontier_hint,
                     new_archive_sibling_path,
@@ -252,6 +250,7 @@ impl TestBuilder {
                 BlockRootRollupPrivateInputs {
                     previous_rollups,
                     message_bundle,
+                    previous_l1_to_l2: self.previous_l1_to_l2,
                     start_msg_sponge,
                     l1_to_l2_message_frontier_hint,
                     new_archive_sibling_path,

noir-projects/noir-protocol-circuits/crates/types/src/abis/block_constant_data.nr

@@ -8,10 +8,10 @@ use std::meta::derive;
 pub struct BlockConstantData {
     // Archive tree snapshot at the very beginning of the entire block.
     pub last_archive: AppendOnlyTreeSnapshot,
-    // L1-to-L2 message tree snapshot after this block lands.
-    // For the first block in a checkpoint, this should be the snapshot after inserting the new l1-to-l2 message subtree
-    // into the last l1-to-l2 tree snapshot in `last_archive`.
-    // For subsequent blocks, this should match the snapshot of the previous block.
+    // L1-to-L2 message tree snapshot after this block's own message bundle has been inserted. The AVM validates this
+    // block's l1-to-l2 message read requests against it, so a tx in this block can read the messages this block
+    // inserts (same-block consumption). Every block-root variant that carries txs asserts this equals its computed
+    // post-bundle root, whether or not the block is the first in its checkpoint.
     pub l1_to_l2_tree_snapshot: AppendOnlyTreeSnapshot,
     pub vk_tree_root: Field,
     pub protocol_contracts_hash: Field,

yarn-project/noir-protocol-circuits-types/src/conversion/server.ts

@@ -906,6 +906,7 @@ export function mapBlockRootRollupPrivateInputsToNoir(
       mapProofDataToNoir(inputs.previousRollups[1], mapTxRollupPublicInputsToNoir),
     ],
     message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle),
+    previous_l1_to_l2: mapAppendOnlyTreeSnapshotToNoir(inputs.previousL1ToL2),
     start_msg_sponge: mapL1ToL2MessageSpongeToNoir(inputs.startMsgSponge),
     l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir),
     new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir),
@@ -918,6 +919,7 @@ export function mapBlockRootSingleTxRollupPrivateInputsToNoir(
   return {
     previous_rollup: mapProofDataToNoir(inputs.previousRollup, mapTxRollupPublicInputsToNoir),
     message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle),
+    previous_l1_to_l2: mapAppendOnlyTreeSnapshotToNoir(inputs.previousL1ToL2),
     start_msg_sponge: mapL1ToL2MessageSpongeToNoir(inputs.startMsgSponge),
     l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir),
     new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir),

yarn-project/prover-client/src/orchestrator/block-proving-state.ts

@@ -303,6 +303,7 @@ export class BlockProvingState {
         inputs: new BlockRootSingleTxRollupPrivateInputs(
           leftRollup,
           messageBundle,
+          this.lastL1ToL2MessageTreeSnapshot,
           startMsgSponge,
           frontierHint,
           this.lastArchiveSiblingPath,
@@ -314,6 +315,7 @@ export class BlockProvingState {
         inputs: new BlockRootRollupPrivateInputs(
           [leftRollup, rightRollup],
           messageBundle,
+          this.lastL1ToL2MessageTreeSnapshot,
           startMsgSponge,
           frontierHint,
           this.lastArchiveSiblingPath,