From 21c5262f2123917a10a571d3c73d13f7818cfc75 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 10:02:56 -0300
Subject: [PATCH 01/22] feat(fast-inbox): flip L1 propose to streaming inbox
 consumption (A-1384)

Switch Rollup.propose from the legacy inbox.consume()/inHash frontier flow to
the streaming-inbox validation (AZIP-22 Fast Inbox):

- ProposeLib.propose calls validateInboxConsumption against the parent
  checkpoint's consumed position, read from the parent temp-log record, and
  stores the returned consumed total in the new record. The Rollup__InvalidInHash
  check and the inbox.consume() call are removed.
- ProposeArgs gains an unsigned bucketHint calldata field (kept out of the
  attested payload digest).
- TempCheckpointLog / CompressedTempCheckpointLog carry the consumption record
  {inboxRollingHash, inboxMsgTotal, inboxConsumedBucket}; genesis is {0,0,0}.
- EpochProofLib.getEpochProofPublicInputs anchors the rolling-hash chain start to
  the record of checkpoint start-1, mirroring previousArchive
  (Rollup__InvalidPreviousInboxRollingHash).
- Inbox.sendL2Message returns and emits the compact cumulative message index.

Frontier trees keep running unread (deleted in cleanup). Propose-path test
harnesses reference the live buckets; inbox index and rolling-hash suites updated
for compact indexing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 l1-contracts/src/core/libraries/Errors.sol    |  1 +
 .../compressed-data/CheckpointLog.sol         | 20 +++++-
 .../core/libraries/rollup/EpochProofLib.sol   | 16 +++++
 .../src/core/libraries/rollup/ProposeLib.sol  | 40 +++++++++---
 .../src/core/libraries/rollup/STFLib.sol      | 27 +++++++-
 l1-contracts/src/core/messagebridge/Inbox.sol |  8 +--
 l1-contracts/test/Inbox.t.sol                 |  3 +-
 l1-contracts/test/InboxBuckets.t.sol          |  3 +-
 l1-contracts/test/Rollup.t.sol                | 64 ++++++++++++++++---
 l1-contracts/test/RollupFieldRange.t.sol      |  9 ++-
 l1-contracts/test/base/RollupBase.sol         | 20 ++++--
 l1-contracts/test/benchmark/happy.t.sol       |  7 +-
 .../test/compression/PreHeating.t.sol         |  7 +-
 .../EscapeHatchIntegrationBase.sol            | 17 ++++-
 .../escape-hatch/integration/invalidate.t.sol |  9 ++-
 .../test/fees/FeeHeaderOverflow.t.sol         | 11 +++-
 l1-contracts/test/fees/FeeRollup.t.sol        | 12 +++-
 l1-contracts/test/fees/MinimalFeeModel.sol    |  5 +-
 l1-contracts/test/harnesses/InboxHarness.sol  |  5 +-
 .../libraries/rewardlib/RewardLibWrapper.sol  |  5 +-
 l1-contracts/test/tmnt419.t.sol               |  9 ++-
 .../ValidatorSelection.t.sol                  |  8 ++-
 .../test/validator-selection/tmnt207.t.sol    |  9 ++-
 23 files changed, 260 insertions(+), 55 deletions(-)

diff --git a/l1-contracts/src/core/libraries/Errors.sol b/l1-contracts/src/core/libraries/Errors.sol
index 98ca02144041..08836f1f0cd7 100644
--- a/l1-contracts/src/core/libraries/Errors.sol
+++ b/l1-contracts/src/core/libraries/Errors.sol
@@ -60,6 +60,7 @@ library Errors {
   error Rollup__InvalidCheckpointNumber(uint256 expected, uint256 actual); // 0xd1ba9bfa
   error Rollup__InvalidInHash(bytes32 expected, bytes32 actual); // 0xcd6f4233
   error Rollup__InvalidInboxRollingHash(bytes32 expected, bytes32 actual); // 0xed1f7bb5
+  error Rollup__InvalidPreviousInboxRollingHash(bytes32 expected, bytes32 actual); // 0x2fe7cae5
   error Rollup__UnconsumedInboxMessages(uint256 nextBucketSeq); // 0x2bd4bf10
   error Rollup__InboxConsumptionBehindParent(uint256 expected, uint256 actual); // 0x54e0c025
   error Rollup__TooManyInboxMessagesConsumed(uint256 consumed); // 0xf76d1426
diff --git a/l1-contracts/src/core/libraries/compressed-data/CheckpointLog.sol b/l1-contracts/src/core/libraries/compressed-data/CheckpointLog.sol
index 486aba1d2bae..cb77b8abd502 100644
--- a/l1-contracts/src/core/libraries/compressed-data/CheckpointLog.sol
+++ b/l1-contracts/src/core/libraries/compressed-data/CheckpointLog.sol
@@ -35,6 +35,13 @@ struct TempCheckpointLog {
   bytes32 payloadDigest;
   Slot slotNumber;
   FeeHeader feeHeader;
+  // Streaming Inbox consumption record (AZIP-22 Fast Inbox). `inboxRollingHash` is the consensus rolling hash the
+  // checkpoint header committed to; `inboxMsgTotal` is the cumulative Inbox message count consumed as of this
+  // checkpoint (the child's parent-total origin); `inboxConsumedBucket` is the bucket sequence number the header's
+  // rolling hash corresponds to. The two counts pack into a single storage slot.
+  bytes32 inboxRollingHash;
+  uint64 inboxMsgTotal;
+  uint64 inboxConsumedBucket;
 }
 
 struct CompressedTempCheckpointLog {
@@ -45,6 +52,9 @@ struct CompressedTempCheckpointLog {
   bytes32 payloadDigest;
   CompressedSlot slotNumber;
   CompressedFeeHeader feeHeader;
+  bytes32 inboxRollingHash;
+  uint64 inboxMsgTotal;
+  uint64 inboxConsumedBucket;
 }
 
 library CompressedTempCheckpointLogLib {
@@ -61,7 +71,10 @@ library CompressedTempCheckpointLogLib {
       attestationsHash: _checkpoint.attestationsHash,
       payloadDigest: _checkpoint.payloadDigest,
       slotNumber: _checkpoint.slotNumber.compress(),
-      feeHeader: _checkpoint.feeHeader.compress()
+      feeHeader: _checkpoint.feeHeader.compress(),
+      inboxRollingHash: _checkpoint.inboxRollingHash,
+      inboxMsgTotal: _checkpoint.inboxMsgTotal,
+      inboxConsumedBucket: _checkpoint.inboxConsumedBucket
     });
   }
 
@@ -77,7 +90,10 @@ library CompressedTempCheckpointLogLib {
       attestationsHash: _compressedCheckpoint.attestationsHash,
       payloadDigest: _compressedCheckpoint.payloadDigest,
       slotNumber: _compressedCheckpoint.slotNumber.decompress(),
-      feeHeader: _compressedCheckpoint.feeHeader.decompress()
+      feeHeader: _compressedCheckpoint.feeHeader.decompress(),
+      inboxRollingHash: _compressedCheckpoint.inboxRollingHash,
+      inboxMsgTotal: _compressedCheckpoint.inboxMsgTotal,
+      inboxConsumedBucket: _compressedCheckpoint.inboxConsumedBucket
     });
   }
 }
diff --git a/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol b/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol
index 1d162cc09534..8c163415fc40 100644
--- a/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol
+++ b/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol
@@ -181,6 +181,22 @@ library EpochProofLib {
           expectedEndArchive == _args.endArchive, Errors.Rollup__InvalidArchive(expectedEndArchive, _args.endArchive)
         );
       }
+
+      {
+        // Start-boundary anchoring for the Inbox rolling-hash chain (AZIP-22 Fast Inbox), mirroring previousArchive:
+        // the proof's claimed chain start must match the rolling hash recorded at propose for checkpoint _start - 1.
+        // No end-side check is needed: the checkpoint root writes the parity end into both the checkpoint header and
+        // end_inbox_rolling_hash, checkpoint merges assert start/end continuity, and verifyHeaders pins the supplied
+        // headers (whose hash covers inboxRollingHash) to the stored header hashes, so a wrong endInboxRollingHash
+        // fails proof verification.
+        bytes32 expectedPreviousInboxRollingHash = STFLib.getInboxRollingHash(_start - 1);
+        require(
+          expectedPreviousInboxRollingHash == _args.previousInboxRollingHash,
+          Errors.Rollup__InvalidPreviousInboxRollingHash(
+            expectedPreviousInboxRollingHash, _args.previousInboxRollingHash
+          )
+        );
+      }
     }
 
     // The fee recipient/value below are sourced from the supplied headers, so the header hashes must be validated here
diff --git a/l1-contracts/src/core/libraries/rollup/ProposeLib.sol b/l1-contracts/src/core/libraries/rollup/ProposeLib.sol
index 7fe3f7d05b95..188d74e99db4 100644
--- a/l1-contracts/src/core/libraries/rollup/ProposeLib.sol
+++ b/l1-contracts/src/core/libraries/rollup/ProposeLib.sol
@@ -20,6 +20,7 @@ import {CompressedSlot, CompressedTimeMath} from "@aztec/shared/libraries/Compre
 import {Signature} from "@aztec/shared/libraries/SignatureLib.sol";
 import {ProposedHeader, ProposedHeaderLib} from "./ProposedHeaderLib.sol";
 import {STFLib} from "./STFLib.sol";
+import {SafeCast} from "@oz/utils/math/SafeCast.sol";
 
 // Streaming-inbox protocol constants (AZIP-22 Fast Inbox). These mirror the protocol circuit constants and
 // should move into the generated Constants library once the Solidity emitter includes them.
@@ -33,6 +34,10 @@ struct ProposeArgs {
   bytes32 archive;
   OracleInput oracleInput;
   ProposedHeader header;
+  // Sequence number of the Inbox bucket the header's `inboxRollingHash` corresponds to (AZIP-22 Fast Inbox).
+  // Unsigned lookup aid kept out of the attested payload digest: a wrong hint can only revert, never change what is
+  // accepted, since integrity comes from the rolling-hash equality check against the committee-signed header.
+  uint256 bucketHint;
 }
 
 struct ProposePayload {
@@ -46,7 +51,9 @@ struct InterimProposeValues {
   bytes32[] blobHashes;
   bytes32 blobsHashesCommitment;
   bytes[] blobCommitments;
-  bytes32 inHash;
+  bytes32 blobCommitmentsHash;
+  FeeHeader feeHeader;
+  uint256 consumedInboxMsgTotal;
   bytes32 headerHash;
   bytes32 attestationsHash;
   bytes32 payloadDigest;
@@ -121,6 +128,7 @@ library ProposeLib {
   using TimeLib for Epoch;
   using CompressedTimeMath for CompressedSlot;
   using ChainTipsLib for CompressedChainTips;
+  using SafeCast for uint256;
 
   /**
    * @notice  Publishes a new checkpoint to the pending chain.
@@ -261,17 +269,31 @@ library ProposeLib {
     uint256 checkpointNumber = tips.getPending() + 1;
     tips = tips.updatePending(checkpointNumber);
 
+    // Validate the streaming Inbox consumption against the parent checkpoint's consumed position (AZIP-22 Fast
+    // Inbox). The parent is checkpointNumber - 1, always available: checkpoint 0 carries the {0,0,0} genesis base
+    // case written at initialization. rollupStore.tips is not committed until below, so the parent read still sees
+    // the parent as the pending tip. The returned cumulative total is stored in this checkpoint's record so its
+    // child validates against it and, since temp-log records rewind with the pending chain on a prune, the record
+    // stays prune-consistent.
+    v.consumedInboxMsgTotal = validateInboxConsumption(
+      rollupStore.config.inbox,
+      v.header.inboxRollingHash,
+      _args.bucketHint,
+      v.header.slotNumber,
+      STFLib.getInboxMsgTotal(checkpointNumber - 1)
+    );
+
     // Calculate accumulated blob commitments hash for this checkpoint
     // Blob commitments are collected and proven per root rollup proof (per epoch),
     // so we need to know whether we are at the epoch start:
     v.isFirstCheckpointOfEpoch =
       v.currentEpoch > STFLib.getEpochForCheckpoint(checkpointNumber - 1) || checkpointNumber == 1;
-    bytes32 blobCommitmentsHash = BlobLib.calculateBlobCommitmentsHash(
+    v.blobCommitmentsHash = BlobLib.calculateBlobCommitmentsHash(
       STFLib.getBlobCommitmentsHash(checkpointNumber - 1), v.blobCommitments, v.isFirstCheckpointOfEpoch
     );
 
     // Compute fee header for checkpoint metadata
-    FeeHeader memory feeHeader = FeeLib.computeFeeHeader(
+    v.feeHeader = FeeLib.computeFeeHeader(
       checkpointNumber,
       _args.oracleInput.feeAssetPriceModifier,
       v.header.totalManaUsed,
@@ -289,20 +311,18 @@ library ProposeLib {
     STFLib.addTempCheckpointLog(
       TempCheckpointLog({
         headerHash: v.headerHash,
-        blobCommitmentsHash: blobCommitmentsHash,
+        blobCommitmentsHash: v.blobCommitmentsHash,
         outHash: v.header.outHash,
         attestationsHash: v.attestationsHash,
         payloadDigest: v.payloadDigest,
         slotNumber: v.header.slotNumber,
-        feeHeader: feeHeader
+        feeHeader: v.feeHeader,
+        inboxRollingHash: v.header.inboxRollingHash,
+        inboxMsgTotal: v.consumedInboxMsgTotal.toUint64(),
+        inboxConsumedBucket: _args.bucketHint.toUint64()
       })
     );
 
-    // Consume pending L1->L2 messages and validate against header commitment
-    // @note  The checkpoint number here will always be >=1 as the genesis checkpoint is at 0
-    v.inHash = rollupStore.config.inbox.consume(checkpointNumber);
-    require(v.header.inHash == v.inHash, Errors.Rollup__InvalidInHash(v.inHash, v.header.inHash));
-
     {
       bytes32 archive = _args.archive;
       if (v.isEscapeHatch) {
diff --git a/l1-contracts/src/core/libraries/rollup/STFLib.sol b/l1-contracts/src/core/libraries/rollup/STFLib.sol
index d776e634157b..f2ef1ed2fa43 100644
--- a/l1-contracts/src/core/libraries/rollup/STFLib.sol
+++ b/l1-contracts/src/core/libraries/rollup/STFLib.sol
@@ -132,7 +132,12 @@ library STFLib {
         slotNumber: Slot.wrap(0),
         feeHeader: FeeHeader({
           excessMana: 0, manaUsed: 0, ethPerFeeAsset: _initialEthPerFeeAsset, congestionCost: 0, proverCost: 0
-        })
+        }),
+        // Genesis Inbox consumption base case, matching the Inbox's genesis bucket-0 sentinel {0, 0, 0}, so
+        // checkpoint 1 validates its consumption against it (AZIP-22 Fast Inbox).
+        inboxRollingHash: bytes32(0),
+        inboxMsgTotal: 0,
+        inboxConsumedBucket: 0
       }).compress();
   }
 
@@ -305,6 +310,26 @@ library STFLib {
     return getStorageTempCheckpointLog(_checkpointNumber).slotNumber.decompress();
   }
 
+  /**
+   * @notice Retrieves the cumulative Inbox message count consumed as of a checkpoint (AZIP-22 Fast Inbox)
+   * @dev Gas-efficient accessor reading only the streaming-inbox consumed total. Reverts if the checkpoint is stale.
+   * @param _checkpointNumber The checkpoint number to get the consumed total for
+   * @return The cumulative Inbox message count consumed as of the checkpoint
+   */
+  function getInboxMsgTotal(uint256 _checkpointNumber) internal view returns (uint64) {
+    return getStorageTempCheckpointLog(_checkpointNumber).inboxMsgTotal;
+  }
+
+  /**
+   * @notice Retrieves the Inbox rolling hash a checkpoint committed to (AZIP-22 Fast Inbox)
+   * @dev Gas-efficient accessor reading only the streaming-inbox rolling hash. Reverts if the checkpoint is stale.
+   * @param _checkpointNumber The checkpoint number to get the rolling hash for
+   * @return The consensus Inbox rolling hash recorded for the checkpoint
+   */
+  function getInboxRollingHash(uint256 _checkpointNumber) internal view returns (bytes32) {
+    return getStorageTempCheckpointLog(_checkpointNumber).inboxRollingHash;
+  }
+
   /**
    * @notice Gets the effective pending checkpoint number based on pruning eligibility
    * @dev Returns either the pending checkpoint number or proven checkpoint number depending on
diff --git a/l1-contracts/src/core/messagebridge/Inbox.sol b/l1-contracts/src/core/messagebridge/Inbox.sol
index 45ee4453498f..3788b3e35205 100644
--- a/l1-contracts/src/core/messagebridge/Inbox.sol
+++ b/l1-contracts/src/core/messagebridge/Inbox.sol
@@ -135,10 +135,10 @@ contract Inbox is IInbox {
       currentTree = trees[inProgress];
     }
 
-    // this is the global leaf index and not index in the checkpoint subtree
-    // such that users can simply use it and don't need access to a node if they are to consume it in public.
-    // trees are constant size so global index = tree number * size + subtree index
-    uint256 index = (inProgress - Constants.INITIAL_CHECKPOINT_NUMBER) * SIZE + currentTree.nextIndex;
+    // Compact cumulative message index (AZIP-22 Fast Inbox): the zero-based position of this message in the Inbox's
+    // insertion order, equal to the number of messages inserted before it. It is embedded in the leaf preimage and
+    // matches the streaming L1-to-L2 tree's leaf count, so consumers do not need per-checkpoint tree geometry.
+    uint256 index = totalMessagesInserted;
 
     // If the sender is the fee asset portal, we use a magic address to simpler have it initialized at genesis.
     // We assume that no-one will know the private key for this address and that the precompile won't change to
diff --git a/l1-contracts/test/Inbox.t.sol b/l1-contracts/test/Inbox.t.sol
index 68cccd760645..b6bd78685573 100644
--- a/l1-contracts/test/Inbox.t.sol
+++ b/l1-contracts/test/Inbox.t.sol
@@ -93,7 +93,8 @@ contract InboxTest is Test {
 
   function testFuzzInsert(DataStructures.L1ToL2Msg memory _message) public checkInvariant {
     Inbox.InboxState memory stateBefore = inbox.getState();
-    uint256 globalLeafIndex = (FIRST_REAL_TREE_NUM - 1) * SIZE;
+    // Compact cumulative index (AZIP-22 Fast Inbox): the message's index is the count inserted before it.
+    uint256 globalLeafIndex = stateBefore.totalMessagesInserted;
     DataStructures.L1ToL2Msg memory message = _boundMessage(_message, globalLeafIndex);
 
     bytes32 leaf = message.sha256ToField();
diff --git a/l1-contracts/test/InboxBuckets.t.sol b/l1-contracts/test/InboxBuckets.t.sol
index c0d89c309d7e..c97b192e4fe6 100644
--- a/l1-contracts/test/InboxBuckets.t.sol
+++ b/l1-contracts/test/InboxBuckets.t.sol
@@ -132,7 +132,8 @@ contract InboxBucketsTest is Test {
       recipient: recipient,
       content: content,
       secretHash: secretHash,
-      index: (FIRST_REAL_TREE_NUM - 1) * (2 ** HEIGHT)
+      // Compact cumulative index (AZIP-22 Fast Inbox): the first message against a fresh Inbox has index 0.
+      index: inbox.getState().totalMessagesInserted
     });
     bytes32 leaf = Hash.sha256ToField(message);
     bytes16 legacyHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, leaf)));
diff --git a/l1-contracts/test/Rollup.t.sol b/l1-contracts/test/Rollup.t.sol
index 2456474939b7..92987ebfc9e0 100644
--- a/l1-contracts/test/Rollup.t.sol
+++ b/l1-contracts/test/Rollup.t.sol
@@ -173,7 +173,9 @@ contract RollupTest is RollupBase {
 
     assertEq(
       inbox.getInProgress(),
-      Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG + 1,
+      // Post-flip the Inbox `consume()` is no longer called at propose, so the frontier in-progress tree no longer
+      // advances per checkpoint; it stays at its initial value until a tree fills (AZIP-22 Fast Inbox).
+      Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG,
       "Invalid in progress"
     );
 
@@ -193,7 +195,9 @@ contract RollupTest is RollupBase {
     rollup.prune();
     assertEq(
       inbox.getInProgress(),
-      Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG + 1,
+      // Post-flip the Inbox `consume()` is no longer called at propose, so the frontier in-progress tree no longer
+      // advances per checkpoint; it stays at its initial value until a tree fills (AZIP-22 Fast Inbox).
+      Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG,
       "Invalid in progress"
     );
     assertEq(rollup.getPendingCheckpointNumber(), 0, "Invalid pending checkpoint number");
@@ -209,7 +213,9 @@ contract RollupTest is RollupBase {
 
     assertEq(
       inbox.getInProgress(),
-      Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG + 1,
+      // Post-flip the Inbox `consume()` is no longer called at propose, so the frontier in-progress tree no longer
+      // advances per checkpoint; it stays at its initial value until a tree fills (AZIP-22 Fast Inbox).
+      Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG,
       "Invalid in progress"
     );
     assertEq(inbox.getRoot(2), inboxRoot2, "Invalid inbox root");
@@ -237,7 +243,8 @@ contract RollupTest is RollupBase {
     bytes32[] memory blobHashes = new bytes32[](1);
     blobHashes[0] = bytes32(uint256(1));
     vm.blobhashes(blobHashes);
-    ProposeArgs memory args = ProposeArgs({header: data.header, archive: data.archive, oracleInput: OracleInput(0)});
+    ProposeArgs memory args =
+      ProposeArgs({header: data.header, archive: data.archive, oracleInput: OracleInput(0), bucketHint: 0});
     bytes32 realBlobHash = this.getBlobHashes(data.blobCommitments)[0];
     vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__InvalidBlobHash.selector, blobHashes[0], realBlobHash));
     rollup.propose(
@@ -326,7 +333,8 @@ contract RollupTest is RollupBase {
     skipBlobCheck(address(rollup));
 
     vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__NonZeroDaFee.selector));
-    ProposeArgs memory args = ProposeArgs({header: header, archive: data.archive, oracleInput: OracleInput(0)});
+    ProposeArgs memory args =
+      ProposeArgs({header: header, archive: data.archive, oracleInput: OracleInput(0), bucketHint: 0});
     rollup.propose(
       args,
       AttestationLibHelper.packAttestations(attestations),
@@ -353,7 +361,8 @@ contract RollupTest is RollupBase {
 
     // When not canonical, we expect the fee to be 0
     vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__InvalidManaMinFee.selector, expectedFee, 1));
-    ProposeArgs memory args = ProposeArgs({header: header, archive: data.archive, oracleInput: OracleInput(0)});
+    ProposeArgs memory args =
+      ProposeArgs({header: header, archive: data.archive, oracleInput: OracleInput(0), bucketHint: 0});
     rollup.propose(
       args,
       AttestationLibHelper.packAttestations(attestations),
@@ -461,8 +470,12 @@ contract RollupTest is RollupBase {
       interim.feeAmount = interim.manaUsed * interim.minFee + interim.portalBalance;
       header.accumulatedFees = interim.feeAmount;
 
+      // Streaming Inbox (AZIP-22 Fast Inbox): nothing is seeded here, so reference the genesis bucket (hash 0).
+      header.inboxRollingHash = bytes32(0);
+
       // Assert that balance have NOT been increased by proposing the checkpoint
-      ProposeArgs memory args = ProposeArgs({header: header, archive: data.archive, oracleInput: OracleInput(0)});
+      ProposeArgs memory args =
+        ProposeArgs({header: header, archive: data.archive, oracleInput: OracleInput(0), bucketHint: 0});
       rollup.propose(
         args,
         AttestationLibHelper.packAttestations(attestations),
@@ -668,7 +681,8 @@ contract RollupTest is RollupBase {
 
     skipBlobCheck(address(rollup));
     vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__InvalidTimestamp.selector, realTs, badTs));
-    ProposeArgs memory args = ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0)});
+    ProposeArgs memory args =
+      ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0), bucketHint: 0});
     rollup.propose(
       args,
       AttestationLibHelper.packAttestations(attestations),
@@ -694,7 +708,8 @@ contract RollupTest is RollupBase {
     vm.blobhashes(blobHashes);
     skipBlobCheck(address(rollup));
     vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__InvalidCoinbase.selector));
-    ProposeArgs memory args = ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0)});
+    ProposeArgs memory args =
+      ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0), bucketHint: 0});
     rollup.propose(
       args,
       AttestationLibHelper.packAttestations(attestations),
@@ -770,7 +785,8 @@ contract RollupTest is RollupBase {
     header.gasFees.feePerL2Gas = uint128(rollup.getManaMinFeeAt(Timestamp.wrap(block.timestamp), true));
 
     vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__NoBlobsInCheckpoint.selector));
-    ProposeArgs memory args = ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0)});
+    ProposeArgs memory args =
+      ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0), bucketHint: 0});
     rollup.propose(
       args,
       AttestationLibHelper.packAttestations(attestations),
@@ -920,6 +936,34 @@ contract RollupTest is RollupBase {
     rollup.getEpochProofPublicInputs(1, 1, args, headers, data.batchedBlobInputs);
   }
 
+  // The epoch-proof anchoring pins the rolling-hash chain start to the record written at propose for checkpoint
+  // start - 1 (AZIP-22 Fast Inbox), mirroring previousArchive. A wrong previousInboxRollingHash must be rejected.
+  function testGetEpochProofPublicInputsRejectsWrongPreviousInboxRollingHash() public setUpFor("empty_checkpoint_1") {
+    _proposeCheckpoint("empty_checkpoint_1", 1);
+
+    DecoderBase.Data memory data = load("empty_checkpoint_1").checkpoint;
+    CheckpointLog memory checkpoint = rollup.getCheckpoint(0);
+
+    ProposedHeader[] memory headers = new ProposedHeader[](1);
+    headers[0] = proposedHeaders[1];
+
+    // Checkpoint 0 is genesis with a zero rolling hash, so any non-zero chain start is wrong.
+    bytes32 wrongPrevious = bytes32(uint256(1));
+    PublicInputArgs memory args = PublicInputArgs({
+      previousArchive: checkpoint.archive,
+      endArchive: data.archive,
+      outHash: data.header.outHash,
+      previousInboxRollingHash: wrongPrevious,
+      endInboxRollingHash: data.header.inboxRollingHash,
+      proverId: address(0)
+    });
+
+    vm.expectRevert(
+      abi.encodeWithSelector(Errors.Rollup__InvalidPreviousInboxRollingHash.selector, bytes32(0), wrongPrevious)
+    );
+    rollup.getEpochProofPublicInputs(1, 1, args, headers, data.batchedBlobInputs);
+  }
+
   function _submitEpochProof(
     uint256 _start,
     uint256 _end,
diff --git a/l1-contracts/test/RollupFieldRange.t.sol b/l1-contracts/test/RollupFieldRange.t.sol
index d10c187e9f75..4e80826d22b3 100644
--- a/l1-contracts/test/RollupFieldRange.t.sol
+++ b/l1-contracts/test/RollupFieldRange.t.sol
@@ -175,7 +175,11 @@ contract RollupFieldRangeTest is RollupBase {
 
     vm.blobhashes(this.getBlobHashes(full.checkpoint.blobCommitments));
 
-    ProposeArgs memory args = ProposeArgs({header: header, archive: bytes32(FIELD_MAX), oracleInput: OracleInput(0)});
+    // Streaming Inbox (AZIP-22 Fast Inbox): nothing is seeded here, so reference the genesis bucket (hash 0).
+    header.inboxRollingHash = bytes32(0);
+
+    ProposeArgs memory args =
+      ProposeArgs({header: header, archive: bytes32(FIELD_MAX), oracleInput: OracleInput(0), bucketHint: 0});
 
     rollup.propose(
       args,
@@ -202,7 +206,8 @@ contract RollupFieldRangeTest is RollupBase {
     skipBlobCheck(address(rollup));
 
     bytes32 archive = _useFixtureArchive ? full.checkpoint.archive : bytes32(_archive);
-    return ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0)});
+    // Boundary tests revert on a field-range check before Inbox consumption; the genesis bucket hint suffices.
+    return ProposeArgs({header: header, archive: archive, oracleInput: OracleInput(0), bucketHint: 0});
   }
 
   function _expectFieldOutOfRange(ProposeArgs memory _args, bytes32 _value) internal {
diff --git a/l1-contracts/test/base/RollupBase.sol b/l1-contracts/test/base/RollupBase.sol
index f75b9875d013..7cf578c45dfd 100644
--- a/l1-contracts/test/base/RollupBase.sol
+++ b/l1-contracts/test/base/RollupBase.sol
@@ -78,8 +78,10 @@ contract RollupBase is DecoderBase {
       previousArchive: parentCheckpointLog.archive,
       endArchive: endFull.checkpoint.archive,
       outHash: endFull.checkpoint.header.outHash,
-      previousInboxRollingHash: 0,
-      endInboxRollingHash: 0,
+      // Anchor the rolling-hash chain start to the record written at propose for checkpoint start - 1 (AZIP-22 Fast
+      // Inbox). The end value is unchecked on L1 but supplied for completeness.
+      previousInboxRollingHash: proposedHeaders[startCheckpointNumber - 1].inboxRollingHash,
+      endInboxRollingHash: proposedHeaders[endCheckpointNumber].inboxRollingHash,
       proverId: _prover
     });
 
@@ -167,7 +169,13 @@ contract RollupBase is DecoderBase {
     vm.warp(max(block.timestamp, Timestamp.unwrap(full.checkpoint.header.timestamp)));
 
     _populateInbox(full.populate.sender, full.populate.recipient, full.populate.l1ToL2Content);
+    // Legacy frontier root for the header's inHash field. Unchecked at propose post-flip, but kept because the
+    // fixtures were generated with it as part of the header hash.
     full.checkpoint.header.inHash = rollup.getInbox().getRoot(full.checkpoint.checkpointNumber);
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket so the checkpoint consumes all messages
+    // seeded above and the mandatory-consumption assert is trivially satisfied (a wrong ref could only revert).
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    full.checkpoint.header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
 
     {
       bytes32[] memory blobHashes;
@@ -197,8 +205,12 @@ contract RollupBase is DecoderBase {
 
     proposedHeaders[full.checkpoint.checkpointNumber] = full.checkpoint.header;
 
-    ProposeArgs memory args =
-      ProposeArgs({header: full.checkpoint.header, archive: full.checkpoint.archive, oracleInput: OracleInput(0)});
+    ProposeArgs memory args = ProposeArgs({
+      header: full.checkpoint.header,
+      archive: full.checkpoint.archive,
+      oracleInput: OracleInput(0),
+      bucketHint: bucketHint
+    });
 
     if (_revertMsg.length > 0) {
       vm.expectRevert(_revertMsg);
diff --git a/l1-contracts/test/benchmark/happy.t.sol b/l1-contracts/test/benchmark/happy.t.sol
index f5f0a900b888..d11f02ae6d9a 100644
--- a/l1-contracts/test/benchmark/happy.t.sol
+++ b/l1-contracts/test/benchmark/happy.t.sol
@@ -274,10 +274,15 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase {
     header.totalManaUsed = manaSpent;
     header.accumulatedFees = uint256(manaMinFee) * manaSpent;
 
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (nothing seeded here, so the genesis bucket).
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
+
     ProposeArgs memory proposeArgs = ProposeArgs({
       header: header,
       archive: archiveRoot,
-      oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier})
+      oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier}),
+      bucketHint: bucketHint
     });
 
     CommitteeAttestation[] memory attestations;
diff --git a/l1-contracts/test/compression/PreHeating.t.sol b/l1-contracts/test/compression/PreHeating.t.sol
index 7cf07a0c9298..aaf1915a8c4a 100644
--- a/l1-contracts/test/compression/PreHeating.t.sol
+++ b/l1-contracts/test/compression/PreHeating.t.sol
@@ -327,10 +327,15 @@ contract PreHeatingTest is FeeModelTestPoints, DecoderBase {
     header.totalManaUsed = manaSpent;
     header.accumulatedFees = uint256(manaMinFee) * manaSpent;
 
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (nothing seeded here, so the genesis bucket).
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
+
     ProposeArgs memory proposeArgs = ProposeArgs({
       header: header,
       archive: archiveRoot,
-      oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier})
+      oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier}),
+      bucketHint: bucketHint
     });
 
     CommitteeAttestation[] memory attestations;
diff --git a/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol b/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol
index 7b2e16301bbb..0436dc40e53c 100644
--- a/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol
+++ b/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol
@@ -155,7 +155,13 @@ abstract contract EscapeHatchIntegrationBase is ValidatorSelectionTestBase {
       accumulatedFees: 0
     });
 
-    args = ProposeArgs({header: header, archive: archive, oracleInput: OracleInput({feeAssetPriceModifier: 0})});
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (genesis here; nothing is seeded).
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
+
+    args = ProposeArgs({
+      header: header, archive: archive, oracleInput: OracleInput({feeAssetPriceModifier: 0}), bucketHint: bucketHint
+    });
 
     blobs = full.checkpoint.blobCommitments;
   }
@@ -205,8 +211,13 @@ abstract contract EscapeHatchIntegrationBase is ValidatorSelectionTestBase {
       header.gasFees.feePerL2Gas = manaMinFee;
     }
 
-    ProposeArgs memory proposeArgs =
-      ProposeArgs({header: header, archive: full.checkpoint.archive, oracleInput: OracleInput(0)});
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (genesis here; nothing is seeded).
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
+
+    ProposeArgs memory proposeArgs = ProposeArgs({
+      header: header, archive: full.checkpoint.archive, oracleInput: OracleInput(0), bucketHint: bucketHint
+    });
 
     skipBlobCheck(address(rollup));
 
diff --git a/l1-contracts/test/escape-hatch/integration/invalidate.t.sol b/l1-contracts/test/escape-hatch/integration/invalidate.t.sol
index f4709a59eabf..fee7f17d26ba 100644
--- a/l1-contracts/test/escape-hatch/integration/invalidate.t.sol
+++ b/l1-contracts/test/escape-hatch/integration/invalidate.t.sol
@@ -139,8 +139,13 @@ contract invalidateTest is EscapeHatchIntegrationBase {
       header.gasFees.feePerL2Gas = manaMinFee;
     }
 
-    ProposeArgs memory proposeArgs =
-      ProposeArgs({header: header, archive: full.checkpoint.archive, oracleInput: OracleInput(0)});
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (genesis here; nothing is seeded).
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
+
+    ProposeArgs memory proposeArgs = ProposeArgs({
+      header: header, archive: full.checkpoint.archive, oracleInput: OracleInput(0), bucketHint: bucketHint
+    });
 
     skipBlobCheck(address(rollup));
 
diff --git a/l1-contracts/test/fees/FeeHeaderOverflow.t.sol b/l1-contracts/test/fees/FeeHeaderOverflow.t.sol
index ed8a7e208798..84a7c85b6b92 100644
--- a/l1-contracts/test/fees/FeeHeaderOverflow.t.sol
+++ b/l1-contracts/test/fees/FeeHeaderOverflow.t.sol
@@ -98,11 +98,20 @@ contract FeeHeaderOverflowTest is DecoderBase {
     header.gasFees.feePerDaGas = 0;
     header.totalManaUsed = 0;
 
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (genesis here; nothing is seeded).
+    uint256 bucketHint = _rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = _rollup.getInbox().getBucket(bucketHint).rollingHash;
+
     CommitteeAttestation[] memory attestations = new CommitteeAttestation[](0);
     address[] memory signers = new address[](0);
 
     return (
-      ProposeArgs({header: header, archive: archiveRoot, oracleInput: OracleInput({feeAssetPriceModifier: 0})}),
+      ProposeArgs({
+        header: header,
+        archive: archiveRoot,
+        oracleInput: OracleInput({feeAssetPriceModifier: 0}),
+        bucketHint: bucketHint
+      }),
       AttestationLibHelper.packAttestations(attestations),
       signers
     );
diff --git a/l1-contracts/test/fees/FeeRollup.t.sol b/l1-contracts/test/fees/FeeRollup.t.sol
index 26d858ee7e71..ac8ef93bd8f3 100644
--- a/l1-contracts/test/fees/FeeRollup.t.sol
+++ b/l1-contracts/test/fees/FeeRollup.t.sol
@@ -269,13 +269,17 @@ contract FeeRollupTest is FeeModelTestPoints, DecoderBase {
       if (rollup.getCurrentSlot() == nextSlot) {
         TestPoint memory point = points[Slot.unwrap(nextSlot) - 1];
         Checkpoint memory b = getCheckpoint();
+        // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (genesis here; nothing is seeded).
+        uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+        b.header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
         skipBlobCheck(address(rollup));
         checkpointHeaders[rollup.getPendingCheckpointNumber() + 1] = b.header;
         rollup.propose(
           ProposeArgs({
             header: b.header,
             archive: b.archive,
-            oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier})
+            oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier}),
+            bucketHint: bucketHint
           }),
           AttestationLibHelper.packAttestations(b.attestations),
           b.signers,
@@ -361,13 +365,17 @@ contract FeeRollupTest is FeeModelTestPoints, DecoderBase {
 
         Checkpoint memory b = getCheckpoint();
 
+        // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (genesis here; nothing is seeded).
+        uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+        b.header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
         skipBlobCheck(address(rollup));
         checkpointHeaders[rollup.getPendingCheckpointNumber() + 1] = b.header;
         rollup.propose(
           ProposeArgs({
             header: b.header,
             archive: b.archive,
-            oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier})
+            oracleInput: OracleInput({feeAssetPriceModifier: point.oracle_input.fee_asset_price_modifier}),
+            bucketHint: bucketHint
           }),
           AttestationLibHelper.packAttestations(b.attestations),
           b.signers,
diff --git a/l1-contracts/test/fees/MinimalFeeModel.sol b/l1-contracts/test/fees/MinimalFeeModel.sol
index f37d6dd4fd7f..24d433406390 100644
--- a/l1-contracts/test/fees/MinimalFeeModel.sol
+++ b/l1-contracts/test/fees/MinimalFeeModel.sol
@@ -126,7 +126,10 @@ contract MinimalFeeModel {
         attestationsHash: bytes32(0),
         payloadDigest: bytes32(0),
         slotNumber: Slot.wrap(0),
-        feeHeader: FeeLib.computeFeeHeader(checkpointNumber, _oracleInput.feeAssetPriceModifier, _manaUsed, 0, 0)
+        feeHeader: FeeLib.computeFeeHeader(checkpointNumber, _oracleInput.feeAssetPriceModifier, _manaUsed, 0, 0),
+        inboxRollingHash: bytes32(0),
+        inboxMsgTotal: 0,
+        inboxConsumedBucket: 0
       })
     );
     //    FeeLib.writeFeeHeader(++populatedThrough, _oracleInput.feeAssetPriceModifier, _manaUsed, 0, 0);
diff --git a/l1-contracts/test/harnesses/InboxHarness.sol b/l1-contracts/test/harnesses/InboxHarness.sol
index 1ba2b3b446ca..1213b0d53e07 100644
--- a/l1-contracts/test/harnesses/InboxHarness.sol
+++ b/l1-contracts/test/harnesses/InboxHarness.sol
@@ -40,8 +40,7 @@ contract InboxHarness is Inbox {
   }
 
   function getNextMessageIndex() external view returns (uint256) {
-    FrontierLib.Tree storage currentTree = trees[state.inProgress];
-    uint256 index = (state.inProgress - Constants.INITIAL_CHECKPOINT_NUMBER) * SIZE + currentTree.nextIndex;
-    return index;
+    // Compact cumulative index (AZIP-22 Fast Inbox): the next message's index is the count inserted so far.
+    return state.totalMessagesInserted;
   }
 }
diff --git a/l1-contracts/test/rollup/libraries/rewardlib/RewardLibWrapper.sol b/l1-contracts/test/rollup/libraries/rewardlib/RewardLibWrapper.sol
index dc37e84e3757..4aa2a583739e 100644
--- a/l1-contracts/test/rollup/libraries/rewardlib/RewardLibWrapper.sol
+++ b/l1-contracts/test/rollup/libraries/rewardlib/RewardLibWrapper.sol
@@ -116,7 +116,10 @@ contract RewardLibWrapper {
         attestationsHash: bytes32(0),
         payloadDigest: bytes32(0),
         slotNumber: Slot.wrap(0),
-        feeHeader: _feeHeader
+        feeHeader: _feeHeader,
+        inboxRollingHash: bytes32(0),
+        inboxMsgTotal: 0,
+        inboxConsumedBucket: 0
       })
     );
   }
diff --git a/l1-contracts/test/tmnt419.t.sol b/l1-contracts/test/tmnt419.t.sol
index 525df4ff47f2..4dbe23a9b31d 100644
--- a/l1-contracts/test/tmnt419.t.sol
+++ b/l1-contracts/test/tmnt419.t.sol
@@ -173,8 +173,13 @@ contract Tmnt419Test is RollupBase {
     header.gasFees.feePerL2Gas = SafeCast.toUint128(rollup.getManaMinFeeAt(Timestamp.wrap(block.timestamp), true));
     header.totalManaUsed = MANA_TARGET;
 
-    ProposeArgs memory proposeArgs =
-      ProposeArgs({header: header, archive: archiveRoot, oracleInput: OracleInput({feeAssetPriceModifier: 0})});
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket so any seeded messages are consumed.
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
+
+    ProposeArgs memory proposeArgs = ProposeArgs({
+      header: header, archive: archiveRoot, oracleInput: OracleInput({feeAssetPriceModifier: 0}), bucketHint: bucketHint
+    });
 
     CommitteeAttestation[] memory attestations = new CommitteeAttestation[](0);
     address[] memory signers = new address[](0);
diff --git a/l1-contracts/test/validator-selection/ValidatorSelection.t.sol b/l1-contracts/test/validator-selection/ValidatorSelection.t.sol
index 722e97dc320a..2fcda6fddbec 100644
--- a/l1-contracts/test/validator-selection/ValidatorSelection.t.sol
+++ b/l1-contracts/test/validator-selection/ValidatorSelection.t.sol
@@ -549,7 +549,13 @@ contract ValidatorSelectionTest is ValidatorSelectionTestBase {
       header.gasFees.feePerL2Gas = manaMinFee;
     }
 
-    ree.proposeArgs = ProposeArgs({header: header, archive: full.checkpoint.archive, oracleInput: OracleInput(0)});
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket, consuming the messages seeded above.
+    uint256 bucketHint = inbox.getCurrentBucketSeq();
+    header.inboxRollingHash = inbox.getBucket(bucketHint).rollingHash;
+
+    ree.proposeArgs = ProposeArgs({
+      header: header, archive: full.checkpoint.archive, oracleInput: OracleInput(0), bucketHint: bucketHint
+    });
 
     skipBlobCheck(address(rollup));
 
diff --git a/l1-contracts/test/validator-selection/tmnt207.t.sol b/l1-contracts/test/validator-selection/tmnt207.t.sol
index 85a34b8f84a1..77442e3db366 100644
--- a/l1-contracts/test/validator-selection/tmnt207.t.sol
+++ b/l1-contracts/test/validator-selection/tmnt207.t.sol
@@ -263,8 +263,13 @@ contract Tmnt207Test is RollupBase {
     header.gasFees.feePerL2Gas = SafeCast.toUint128(rollup.getManaMinFeeAt(Timestamp.wrap(block.timestamp), true));
     header.totalManaUsed = MANA_TARGET;
 
-    ProposeArgs memory proposeArgs =
-      ProposeArgs({header: header, archive: archiveRoot, oracleInput: OracleInput({feeAssetPriceModifier: 0})});
+    // Streaming Inbox (AZIP-22 Fast Inbox): reference the newest bucket (genesis here; nothing is seeded).
+    uint256 bucketHint = rollup.getInbox().getCurrentBucketSeq();
+    header.inboxRollingHash = rollup.getInbox().getBucket(bucketHint).rollingHash;
+
+    ProposeArgs memory proposeArgs = ProposeArgs({
+      header: header, archive: archiveRoot, oracleInput: OracleInput({feeAssetPriceModifier: 0}), bucketHint: bucketHint
+    });
 
     CommitteeAttestation[] memory attestations;
     address[] memory signers;

From f1e86edce0857f2b3bfc6c7df88a0cf6db3ba87e Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 10:21:38 -0300
Subject: [PATCH 02/22] feat(fast-inbox): drop bundle padding and per-block
 blob root in circuits (A-1384)

Flip the block-root circuits to the streaming inbox (AZIP-22 Fast Inbox):

- MAX_L1_TO_L2_MSGS_PER_BLOCK 1024 -> 256 (per-checkpoint cap and the InboxParity
  size ladder are unchanged).
- L1ToL2MessageBundle drops num_real_msgs; a single num_msgs count drives both the
  compact (unpadded) tree append and the message-sponge absorb.
- BlockRollupPublicInputsComposer::with_message_bundle appends and absorbs the real
  num_msgs leaves and drops the dual-count assert.
- SpongeBlob::absorb_block_end_data absorbs the L1-to-L2 tree root for every block
  (the root is now per-block), dropping the is_first_block_in_checkpoint gating.

InboxParity already absorbs the real count (A-1427), so the checkpoint-root sponge
equality holds. VK and Prover.toml sample-input regen ride CI.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/abis/l1_to_l2_message_bundle.nr       | 18 ++++------
 .../block_root/block_root_msgs_only_rollup.nr |  2 +-
 .../block_rollup_public_inputs_composer.nr    | 36 ++++++-------------
 .../rollup-lib/src/block_root/tests/mod.nr    | 12 ++-----
 .../src/block_root/tests/msgs_only_tests.nr   |  2 --
 .../src/parity/tests/inbox_parity_tests.nr    |  2 +-
 .../crates/types/src/blob_data/sponge_blob.nr | 14 +++-----
 .../crates/types/src/constants.nr             |  7 ++--
 8 files changed, 29 insertions(+), 64 deletions(-)

diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_bundle.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_bundle.nr
index 24b206855625..dd015f2b1d5c 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_bundle.nr
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_bundle.nr
@@ -4,26 +4,20 @@ use types::{
     traits::{Deserialize, Empty, Serialize},
 };
 
-/// A block's L1-to-L2 message bundle: the leaves it inserts into the L1-to-L2 message tree, plus the counts a block
-/// root needs to append them and absorb them into the message sponge.
+/// A block's L1-to-L2 message bundle: the real message leaves it inserts into the L1-to-L2 message tree, and the
+/// count a block root needs to append them and absorb them into the message sponge (AZIP-22 Fast Inbox).
 ///
-/// It carries two counts on purpose. Transitionally the L1-to-L2 tree insert is a fixed padded subtree while the
-/// message sponge (and the checkpoint's `InboxParity` proof) work at the real message count, so the two differ:
-/// - `num_msgs` — leaves appended to the tree (the padded subtree size for a message-bearing block, 0 for an empty
-///   one).
-/// - `num_real_msgs` — real (non-padding) messages absorbed into the message sponge.
-///
-/// Once the L1-to-L2 tree insert becomes real-count too (the Fast Inbox flip), `num_msgs == num_real_msgs` and
-/// `num_real_msgs` is dropped, leaving this struct otherwise unchanged.
+/// The `num_msgs` real messages occupy the leading lanes; the same count drives both the compact (unpadded) tree
+/// append and the message-sponge absorb, matching the checkpoint's variable-size `InboxParity` proof. Lanes past
+/// `num_msgs` are zero padding.
 #[derive(Deserialize, Eq, Serialize)]
 pub struct L1ToL2MessageBundle {
     pub messages: [Field; MAX_L1_TO_L2_MSGS_PER_BLOCK],
     pub num_msgs: u32,
-    pub num_real_msgs: u32,
 }
 
 impl Empty for L1ToL2MessageBundle {
     fn empty() -> Self {
-        L1ToL2MessageBundle { messages: [0; MAX_L1_TO_L2_MSGS_PER_BLOCK], num_msgs: 0, num_real_msgs: 0 }
+        L1ToL2MessageBundle { messages: [0; MAX_L1_TO_L2_MSGS_PER_BLOCK], num_msgs: 0 }
     }
 }
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_msgs_only_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_msgs_only_rollup.nr
index becd18212ba4..6f05226552ed 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_msgs_only_rollup.nr
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_msgs_only_rollup.nr
@@ -59,7 +59,7 @@ pub fn execute(inputs: BlockRootMsgsOnlyRollupPrivateInputs) -> BlockRollupPubli
     // A message-only block exists solely to insert L1-to-L2 messages, so it must carry at least one real message. This
     // prevents a provable, fully-empty non-first filler block.
     assert(
-        inputs.message_bundle.num_real_msgs != 0,
+        inputs.message_bundle.num_msgs != 0,
         "A message-only block must insert at least one L1-to-L2 message",
     );
 
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr
index e4d6d7fb48c8..52f06040d8e6 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr
@@ -138,10 +138,9 @@ impl BlockRollupPublicInputsComposer {
     /// 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
-    /// only `bundle.num_real_msgs` real leaves so it matches the checkpoint's variable-size `InboxParity` proof. The
-    /// padding lanes past `num_real_msgs` must be zero.
+    /// A single `bundle.num_msgs` count drives both the compact (unpadded) tree append and the message-sponge absorb,
+    /// so the sponge matches the checkpoint's variable-size `InboxParity` proof (AZIP-22 Fast Inbox). The lanes past
+    /// `num_msgs` must be zero.
     pub fn with_message_bundle(
         &mut self,
         is_first_block: bool,
@@ -153,20 +152,10 @@ impl BlockRollupPublicInputsComposer {
         self.is_first_block = is_first_block;
         self.previous_l1_to_l2 = previous_l1_to_l2;
 
-        // Real messages occupy the leading lanes; everything past `num_real_msgs` is zero padding, including the
-        // padding that fills out the tree's fixed subtree insert.
-        assert_trailing_zeros(bundle.messages, bundle.num_real_msgs);
+        // Real messages occupy the leading lanes; everything past `num_msgs` is zero padding.
+        assert_trailing_zeros(bundle.messages, bundle.num_msgs);
 
-        // The sponge absorbs a prefix of what the tree inserts, so the real count can never exceed the insert count.
-        assert(bundle.num_real_msgs <= bundle.num_msgs, "more real messages than tree leaves");
-
-        // NOTE: `num_msgs` (the tree-insert count) is not otherwise pinned in-circuit — nothing here forces it to the
-        // padded subtree size. On the honest path the orchestrator sets it to `MAX_L1_TO_L2_MSGS_PER_BLOCK` for the
-        // first block and 0 otherwise, and the resulting `new_l1_to_l2` snapshot is what binds it (first-block variants
-        // check it against the tx-constants snapshot, ultimately the L1 pending-chain header hash). Like the
-        // unconstrained `in_hash`, a fully trustless binding is deferred to the Fast Inbox flip.
-
-        // Append the bundle to the l1-to-l2 message tree at its current (arbitrary) next-available index.
+        // Append the real leaves to the l1-to-l2 message tree at its current (compact, unaligned) next-available index.
         self.new_l1_to_l2 = append_only_tree::append_leaves_to_snapshot::<L1_TO_L2_MSG_TREE_HEIGHT, _>(
             previous_l1_to_l2,
             bundle.messages,
@@ -174,10 +163,10 @@ impl BlockRollupPublicInputsComposer {
             frontier_hint,
         );
 
-        // Absorb the real leaves into the message sponge, threading it from the previous block.
+        // Absorb the same real leaves into the message sponge, threading it from the previous block.
         self.start_msg_sponge = start_msg_sponge;
         let mut end_msg_sponge = start_msg_sponge;
-        end_msg_sponge.absorb(bundle.messages, bundle.num_real_msgs);
+        end_msg_sponge.absorb(bundle.messages, bundle.num_msgs);
         self.end_msg_sponge = end_msg_sponge;
 
         *self
@@ -266,20 +255,17 @@ impl BlockRollupPublicInputsComposer {
             gas_fees: self.constants.gas_fees,
         };
 
-        // Absorb data for this block into the end sponge blob.
+        // Absorb data for this block into the end sponge blob. The l1-to-l2 message tree root is absorbed for every
+        // block (AZIP-22 Fast Inbox): any block can insert its own bundle, so the root is per-block, not
+        // checkpoint-constant.
         let mut block_end_sponge_blob = self.end_sponge_blob;
 
-        // The l1-to-l2 message tree root is absorbed only for the first block of a checkpoint (the value is shared by
-        // all blocks in the checkpoint). `is_first_block` is asserted true at the checkpoint root and false for every
-        // non-first ("right") rollup in `validate_consecutive_block_rollups.nr`, so it can only be true for the first
-        // block. This replaces the former `in_hash != 0` derivation.
         block_end_sponge_blob.absorb_block_end_data(
             global_variables,
             last_archive,
             state,
             self.num_txs,
             self.accumulated_mana_used,
-            self.is_first_block,
         );
 
         // Duplicate the `block_end_sponge_blob` so that we can squeeze it.
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr
index 149ab9acea80..5808789848be 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr
@@ -259,15 +259,10 @@ impl TestBuilder {
         }
     }
 
-    // The block's message bundle. The unit-test fixture inserts exactly `num_msgs` real leaves into the tree, so the
-    // tree-insert count and the sponge real-count are equal here; the transitional gap between them (padded tree
-    // insert vs real-count sponge) is exercised by the orchestrator and full-rollup tests.
+    // The block's message bundle: exactly `num_msgs` real leaves, appended compactly to the tree and absorbed into the
+    // message sponge (AZIP-22 Fast Inbox).
     fn message_bundle(self) -> L1ToL2MessageBundle {
-        L1ToL2MessageBundle {
-            messages: self.l1_to_l2_messages,
-            num_msgs: self.num_msgs,
-            num_real_msgs: self.num_msgs,
-        }
+        L1ToL2MessageBundle { messages: self.l1_to_l2_messages, num_msgs: self.num_msgs }
     }
 
     pub fn assert_expected_public_inputs(self, pi: BlockRollupPublicInputs) {
@@ -322,7 +317,6 @@ impl TestBuilder {
             pi.end_state,
             self.num_left_txs + self.num_right_txs,
             pi.accumulated_mana_used,
-            self.is_first_block_root,
         );
         assert_eq(pi.end_sponge_blob, expected_end_sponge_blob);
 
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/msgs_only_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/msgs_only_tests.nr
index a1f92176146c..9c9a9424d96a 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/msgs_only_tests.nr
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/msgs_only_tests.nr
@@ -79,7 +79,6 @@ impl TestBuilder {
             message_bundle: L1ToL2MessageBundle {
                 messages: self.l1_to_l2_messages,
                 num_msgs: self.num_msgs,
-                num_real_msgs: self.num_msgs,
             },
             l1_to_l2_message_frontier_hint: self.l1_to_l2_message_frontier_hint,
             new_archive_sibling_path: self.new_archive_sibling_path,
@@ -109,7 +108,6 @@ impl TestBuilder {
             pi.end_state,
             0, // num_txs
             0, // total_mana_used
-            false, // is_first_block
         );
         assert_eq(pi.end_sponge_blob, expected_end_sponge_blob);
 
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr
index 73f4565d9c6a..3ec816a2eb0d 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr
@@ -94,7 +94,7 @@ fn sponge_matches_block_root_real_count_absorb() {
     };
     let public_inputs = inbox_parity::execute(private_inputs);
 
-    // A block root absorbing the same two real leaves out of its 1024-wide bundle reaches the same sponge.
+    // A block root absorbing the same two real leaves out of its wider bundle reaches the same sponge.
     let mut block_sponge = L1ToL2MessageSponge::empty();
     block_sponge.absorb([101, 202, 0, 0, 0], 2);
     assert_eq(public_inputs.end_sponge, block_sponge);
diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr b/noir-projects/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr
index 9467ca4bd1eb..af057122b328 100644
--- a/noir-projects/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr
+++ b/noir-projects/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr
@@ -127,7 +127,6 @@ impl SpongeBlob {
         state: StateReference,
         num_txs: u16,
         total_mana_used: Field,
-        is_first_block_in_checkpoint: bool,
     ) {
         let blob_data = create_block_end_blob_data(
             global_variables,
@@ -137,15 +136,10 @@ impl SpongeBlob {
             total_mana_used,
         );
 
-        // Include the last field (the l1-to-l2 message tree root) only for the first block, since this value is the
-        // same for all blocks in the checkpoint.
-        let num_blob_data_to_absorb = if is_first_block_in_checkpoint {
-            blob_data.len()
-        } else {
-            blob_data.len() - 1
-        };
-
-        self.absorb(blob_data, num_blob_data_to_absorb);
+        // The l1-to-l2 message tree root (the last field) is absorbed for every block (AZIP-22 Fast Inbox): any block
+        // can now insert its own bundle, so the root differs per block and blob-syncing nodes reconstruct each block's
+        // message-tree root from the blob alone.
+        self.absorb(blob_data, blob_data.len());
     }
 
     /// |----------|---------------------------------------------|---------|
diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr
index 24016f2abc0d..41f8cae4762f 100644
--- a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr
+++ b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr
@@ -63,10 +63,9 @@ pub global NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH: u32 =
     NULLIFIER_TREE_HEIGHT - NULLIFIER_SUBTREE_HEIGHT;
 pub global L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH: u32 =
     L1_TO_L2_MSG_TREE_HEIGHT - L1_TO_L2_MSG_SUBTREE_HEIGHT;
-// Cap on L1-to-L2 messages bundled into a single L2 block. Transitional value equal to the per-checkpoint cap: the
-// constant is deliberately oversized so the first block's bundle can carry a whole checkpoint's padded messages during
-// the transition, and drops to 256 at the flip.
-pub global MAX_L1_TO_L2_MSGS_PER_BLOCK: u32 = 1024;
+// Cap on L1-to-L2 messages bundled into a single L2 block (AZIP-22 Fast Inbox). One quarter of the per-checkpoint
+// cap: a checkpoint drains its Inbox consumption across up to four message-bearing blocks.
+pub global MAX_L1_TO_L2_MSGS_PER_BLOCK: u32 = 256;
 // Cap on L1-to-L2 messages consumed by a single checkpoint. Semantically today's NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP.
 pub global MAX_L1_TO_L2_MSGS_PER_CHECKPOINT: u32 = 1024;
 // Minimum bucket age, in seconds, at the start of a checkpoint's build frame for its consumption to be mandatory under

From 9d0ada471ee48f427a97b73b8f38f2caeda9dc6b Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 10:32:16 -0300
Subject: [PATCH 03/22] feat(fast-inbox): per-block blob root and 256 msg/block
 constant in the node (A-1384)

Mirror the circuit blob-format flip in the node (AZIP-22 Fast Inbox):

- Regenerate MAX_L1_TO_L2_MSGS_PER_BLOCK to 256 in @aztec/constants.
- Every block's blob carries the L1-to-L2 message tree root; drop the first-block
  conditional in encode/decode, the producers (L2Block, prover orchestrator), and
  the NUM_FIRST_BLOCK_END_BLOB_FIELDS distinction.
- getNumBlockEndBlobFields loses its parameter; blob capacity accounting spends the
  block-end overhead (now 7 fields) for every block, dropping the provable
  per-checkpoint ceiling from 2457 to 2234.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/encoding/block_blob_data.test.ts      | 29 +++++--------------
 .../blob-lib/src/encoding/block_blob_data.ts  | 29 +++++++++----------
 .../src/encoding/checkpoint_blob_data.ts      |  6 ++--
 .../blob-lib/src/encoding/fixtures.ts         |  3 +-
 yarn-project/constants/src/constants.gen.ts   |  2 +-
 .../orchestrator/block-building-helpers.ts    |  3 +-
 .../src/orchestrator/block-proving-state.ts   |  3 +-
 yarn-project/stdlib/src/block/l2_block.ts     |  4 +--
 .../deserialization/deserialization.test.ts   | 10 +++----
 .../stdlib/src/deserialization/index.ts       | 14 ++++-----
 .../stdlib/src/gas/tx_gas_limits.test.ts      |  3 +-
 yarn-project/stdlib/src/gas/tx_gas_limits.ts  | 16 +++-------
 .../src/checkpoint_builder.test.ts            |  4 +--
 .../src/checkpoint_builder.ts                 |  3 +-
 14 files changed, 52 insertions(+), 77 deletions(-)

diff --git a/yarn-project/blob-lib/src/encoding/block_blob_data.test.ts b/yarn-project/blob-lib/src/encoding/block_blob_data.test.ts
index cd291c70c778..f7a92a2b38c3 100644
--- a/yarn-project/blob-lib/src/encoding/block_blob_data.test.ts
+++ b/yarn-project/blob-lib/src/encoding/block_blob_data.test.ts
@@ -3,38 +3,23 @@ import { makeBlockBlobData } from './fixtures.js';
 
 describe('block blob data', () => {
   it('encode and decode first block', () => {
-    const isFirstBlock = true;
-    const numTxs = 3;
-    const blockBlobData = makeBlockBlobData({ isFirstBlock, numTxs });
+    const blockBlobData = makeBlockBlobData({ isFirstBlock: true, numTxs: 3 });
     expect(blockBlobData.txs.length).toBe(3);
     expect(blockBlobData.l1ToL2MessageRoot).toBeDefined();
 
     const encoded = encodeBlockBlobData(blockBlobData);
-    const decoded = decodeBlockBlobData(encoded, isFirstBlock);
+    const decoded = decodeBlockBlobData(encoded);
     expect(decoded).toEqual(blockBlobData);
   });
 
-  it('encode and decode second block', () => {
-    const isFirstBlock = false;
-    const numTxs = 3;
-    const blockBlobData = makeBlockBlobData({ isFirstBlock, numTxs });
+  it('encode and decode non-first block (still carries the l1-to-l2 root)', () => {
+    const blockBlobData = makeBlockBlobData({ isFirstBlock: false, numTxs: 3 });
     expect(blockBlobData.txs.length).toBe(3);
-    expect(blockBlobData.l1ToL2MessageRoot).toBeUndefined();
+    // Every block carries the l1-to-l2 message tree root post-flip (AZIP-22 Fast Inbox).
+    expect(blockBlobData.l1ToL2MessageRoot).toBeDefined();
 
     const encoded = encodeBlockBlobData(blockBlobData);
-    const decoded = decodeBlockBlobData(encoded, isFirstBlock);
+    const decoded = decodeBlockBlobData(encoded);
     expect(decoded).toEqual(blockBlobData);
   });
-
-  it('does not include l1ToL2MessageRoot if not first block', () => {
-    const blockBlobData = makeBlockBlobData({ isFirstBlock: true, numTxs: 3 });
-    const { l1ToL2MessageRoot, ...blockBlobDataWithoutL1ToL2MessageRoot } = blockBlobData;
-    // l1ToL2MessageRoot exists in the blob data.
-    expect(l1ToL2MessageRoot).toBeDefined();
-
-    const encoded = encodeBlockBlobData(blockBlobData);
-    // isFirstBlock is false. The l1ToL2MessageRoot should be ignored.
-    const decoded = decodeBlockBlobData(encoded, false);
-    expect(decoded).toEqual(blockBlobDataWithoutL1ToL2MessageRoot);
-  });
 });
diff --git a/yarn-project/blob-lib/src/encoding/block_blob_data.ts b/yarn-project/blob-lib/src/encoding/block_blob_data.ts
index 8d8d9d83ba60..007503617d3d 100644
--- a/yarn-project/blob-lib/src/encoding/block_blob_data.ts
+++ b/yarn-project/blob-lib/src/encoding/block_blob_data.ts
@@ -17,16 +17,15 @@ import { type TxBlobData, decodeTxBlobData, encodeTxBlobData } from './tx_blob_d
 
 // Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
 
-export const NUM_BLOCK_END_BLOB_FIELDS = 6;
-export const NUM_FIRST_BLOCK_END_BLOB_FIELDS = 7;
+// Every block carries the L1-to-L2 message tree root (AZIP-22 Fast Inbox): once any block can insert its own
+// message bundle, the root is per-block, so blob-syncing nodes reconstruct each block's message-tree root from the
+// blob alone.
+export const NUM_BLOCK_END_BLOB_FIELDS = 7;
 export const NUM_CHECKPOINT_END_MARKER_FIELDS = 1;
 
-/**
- * Returns the number of blob fields used for block end data.
- * @param isFirstBlockInCheckpoint - Whether this is the first block in a checkpoint.
- */
-export function getNumBlockEndBlobFields(isFirstBlockInCheckpoint: boolean): number {
-  return isFirstBlockInCheckpoint ? NUM_FIRST_BLOCK_END_BLOB_FIELDS : NUM_BLOCK_END_BLOB_FIELDS;
+/** Returns the number of blob fields used for block end data. */
+export function getNumBlockEndBlobFields(): number {
+  return NUM_BLOCK_END_BLOB_FIELDS;
 }
 
 export interface BlockEndBlobData {
@@ -36,7 +35,7 @@ export interface BlockEndBlobData {
   noteHashRoot: Fr;
   nullifierRoot: Fr;
   publicDataRoot: Fr;
-  l1ToL2MessageRoot: Fr | undefined;
+  l1ToL2MessageRoot: Fr;
 }
 
 export interface BlockBlobData extends BlockEndBlobData {
@@ -51,14 +50,14 @@ export function encodeBlockEndBlobData(blockEndBlobData: BlockEndBlobData): Fr[]
     blockEndBlobData.noteHashRoot,
     blockEndBlobData.nullifierRoot,
     blockEndBlobData.publicDataRoot,
-    ...(blockEndBlobData.l1ToL2MessageRoot ? [blockEndBlobData.l1ToL2MessageRoot] : []),
+    blockEndBlobData.l1ToL2MessageRoot,
   ];
 }
 
-export function decodeBlockEndBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockEndBlobData {
+export function decodeBlockEndBlobData(fields: Fr[] | FieldReader): BlockEndBlobData {
   const reader = FieldReader.asReader(fields);
 
-  const numBlockEndData = getNumBlockEndBlobFields(isFirstBlock);
+  const numBlockEndData = getNumBlockEndBlobFields();
   if (numBlockEndData > reader.remainingFields()) {
     throw new BlobDeserializationError(
       `Incorrect encoding of blob fields: not enough fields for block end data. Expected ${numBlockEndData} fields, only ${reader.remainingFields()} remaining.`,
@@ -72,7 +71,7 @@ export function decodeBlockEndBlobData(fields: Fr[] | FieldReader, isFirstBlock:
     noteHashRoot: reader.readField(),
     nullifierRoot: reader.readField(),
     publicDataRoot: reader.readField(),
-    l1ToL2MessageRoot: isFirstBlock ? reader.readField() : undefined,
+    l1ToL2MessageRoot: reader.readField(),
   };
 }
 
@@ -80,7 +79,7 @@ export function encodeBlockBlobData(blockBlobData: BlockBlobData): Fr[] {
   return [...blockBlobData.txs.map(tx => encodeTxBlobData(tx)).flat(), ...encodeBlockEndBlobData(blockBlobData)];
 }
 
-export function decodeBlockBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockBlobData {
+export function decodeBlockBlobData(fields: Fr[] | FieldReader): BlockBlobData {
   const reader = FieldReader.asReader(fields);
 
   const txs: TxBlobData[] = [];
@@ -98,7 +97,7 @@ export function decodeBlockBlobData(fields: Fr[] | FieldReader, isFirstBlock: bo
     }
   }
 
-  const blockEndBlobData = decodeBlockEndBlobData(reader, isFirstBlock);
+  const blockEndBlobData = decodeBlockEndBlobData(reader);
 
   const blockEndMarker = blockEndBlobData.blockEndMarker;
   if (blockEndMarker.numTxs !== txs.length) {
diff --git a/yarn-project/blob-lib/src/encoding/checkpoint_blob_data.ts b/yarn-project/blob-lib/src/encoding/checkpoint_blob_data.ts
index ad786affd9db..aff4ac2b1588 100644
--- a/yarn-project/blob-lib/src/encoding/checkpoint_blob_data.ts
+++ b/yarn-project/blob-lib/src/encoding/checkpoint_blob_data.ts
@@ -6,7 +6,6 @@ import {
   type BlockBlobData,
   NUM_BLOCK_END_BLOB_FIELDS,
   NUM_CHECKPOINT_END_MARKER_FIELDS,
-  NUM_FIRST_BLOCK_END_BLOB_FIELDS,
   decodeBlockBlobData,
   encodeBlockBlobData,
 } from './block_blob_data.js';
@@ -46,7 +45,7 @@ export function decodeCheckpointBlobData(fields: Fr[] | FieldReader): Checkpoint
   const blocks = [];
   let checkpointEndMarker: CheckpointEndMarker | undefined;
   while (!reader.isFinished() && !checkpointEndMarker) {
-    blocks.push(decodeBlockBlobData(reader, blocks.length === 0 /* isFirstBlock */));
+    blocks.push(decodeBlockBlobData(reader));
 
     // After reading a block, the next item must be either a checkpoint end marker or another block.
     // The first field of a block is always a tx start marker. So if the provided fields are valid, it's not possible to
@@ -94,8 +93,7 @@ export function getTotalNumBlobFieldsFromTxs(txsPerBlock: TxStartMarker[][]): nu
   }
 
   return (
-    (numBlocks ? NUM_FIRST_BLOCK_END_BLOB_FIELDS - NUM_BLOCK_END_BLOB_FIELDS : 0) + // l1ToL2Messages root in the first block
-    numBlocks * NUM_BLOCK_END_BLOB_FIELDS + // 6 fields for each block end blob data.
+    numBlocks * NUM_BLOCK_END_BLOB_FIELDS + // block-end fields for each block (includes the per-block l1-to-l2 root)
     txsPerBlock.reduce((total, txs) => total + txs.reduce((total, tx) => total + tx.numBlobFields, 0), 0) +
     NUM_CHECKPOINT_END_MARKER_FIELDS // checkpoint end marker
   );
diff --git a/yarn-project/blob-lib/src/encoding/fixtures.ts b/yarn-project/blob-lib/src/encoding/fixtures.ts
index ab146d5c5dea..fd81707febec 100644
--- a/yarn-project/blob-lib/src/encoding/fixtures.ts
+++ b/yarn-project/blob-lib/src/encoding/fixtures.ts
@@ -152,7 +152,8 @@ export function makeBlockEndBlobData({
     noteHashRoot: fr(seed + 0x300),
     nullifierRoot: fr(seed + 0x400),
     publicDataRoot: fr(seed + 0x500),
-    l1ToL2MessageRoot: isFirstBlock ? fr(seed + 0x600) : undefined,
+    // Every block carries the l1-to-l2 message tree root post-flip (AZIP-22 Fast Inbox).
+    l1ToL2MessageRoot: fr(seed + 0x600),
     ...blockEndBlobDataOverrides,
   };
 }
diff --git a/yarn-project/constants/src/constants.gen.ts b/yarn-project/constants/src/constants.gen.ts
index 276c5997c209..80d67b8fa322 100644
--- a/yarn-project/constants/src/constants.gen.ts
+++ b/yarn-project/constants/src/constants.gen.ts
@@ -29,7 +29,7 @@ export const L1_TO_L2_MSG_SUBTREE_HEIGHT = 10;
 export const NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH = 36;
 export const NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH = 36;
 export const L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH = 26;
-export const MAX_L1_TO_L2_MSGS_PER_BLOCK = 1024;
+export const MAX_L1_TO_L2_MSGS_PER_BLOCK = 256;
 export const MAX_L1_TO_L2_MSGS_PER_CHECKPOINT = 1024;
 export const INBOX_LAG_SECONDS = 12;
 export const MAX_L2_TO_L1_MSG_SUBTREES_PER_TX = 3;
diff --git a/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts b/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
index 01c0726d70bb..a49990f9c877 100644
--- a/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
+++ b/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
@@ -341,7 +341,8 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
       noteHashRoot: partial.noteHashTree.root,
       nullifierRoot: partial.nullifierTree.root,
       publicDataRoot: partial.publicDataTree.root,
-      l1ToL2MessageRoot: isFirstBlock ? l1ToL2MessageTree.root : undefined,
+      // Every block carries its own post-bundle l1-to-l2 message tree root (AZIP-22 Fast Inbox).
+      l1ToL2MessageRoot: l1ToL2MessageTree.root,
       txs: body.toTxBlobData(),
     });
 
diff --git a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
index 83c7ed4bdf14..63b734cb200c 100644
--- a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
+++ b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
@@ -263,7 +263,8 @@ export class BlockProvingState {
       noteHashRoot: partial.noteHashTree.root,
       nullifierRoot: partial.nullifierTree.root,
       publicDataRoot: partial.publicDataTree.root,
-      l1ToL2MessageRoot: this.isFirstBlock ? this.newL1ToL2MessageTreeSnapshot.root : undefined,
+      // Every block carries its own post-bundle l1-to-l2 message tree root (AZIP-22 Fast Inbox).
+      l1ToL2MessageRoot: this.newL1ToL2MessageTreeSnapshot.root,
     };
   }
 
diff --git a/yarn-project/stdlib/src/block/l2_block.ts b/yarn-project/stdlib/src/block/l2_block.ts
index e7c78f332a1d..efd6b4833efe 100644
--- a/yarn-project/stdlib/src/block/l2_block.ts
+++ b/yarn-project/stdlib/src/block/l2_block.ts
@@ -116,7 +116,6 @@ export class L2Block {
   }
 
   public toBlockBlobData(): BlockBlobData {
-    const isFirstBlock = this.indexWithinCheckpoint === 0;
     return {
       blockEndMarker: {
         numTxs: this.body.txEffects.length,
@@ -134,7 +133,8 @@ export class L2Block {
       noteHashRoot: this.header.state.partial.noteHashTree.root,
       nullifierRoot: this.header.state.partial.nullifierTree.root,
       publicDataRoot: this.header.state.partial.publicDataTree.root,
-      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
+      // Every block carries its own post-bundle l1-to-l2 message tree root (AZIP-22 Fast Inbox).
+      l1ToL2MessageRoot: this.header.state.l1ToL2MessageTree.root,
       txs: this.body.toTxBlobData(),
     };
   }
diff --git a/yarn-project/stdlib/src/deserialization/deserialization.test.ts b/yarn-project/stdlib/src/deserialization/deserialization.test.ts
index 274953c9af19..7bd23cc96f1f 100644
--- a/yarn-project/stdlib/src/deserialization/deserialization.test.ts
+++ b/yarn-project/stdlib/src/deserialization/deserialization.test.ts
@@ -1,7 +1,6 @@
 import {
   NUM_BLOCK_END_BLOB_FIELDS,
   NUM_CHECKPOINT_END_MARKER_FIELDS,
-  NUM_FIRST_BLOCK_END_BLOB_FIELDS,
   getNumTxBlobFields,
 } from '@aztec/blob-lib/encoding';
 import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
@@ -23,13 +22,14 @@ describe('MAX_CAPACITY_BLOCKS_PER_CHECKPOINT', () => {
   });
 
   // Largest checkpoint that fits in the blob budget with the most compact construction:
-  // one (possibly empty) first block + (N - 1) single-nullifier blocks + a checkpoint-end marker.
+  // one (possibly empty) first block + (N - 1) single-nullifier blocks + a checkpoint-end marker. Every block
+  // spends the same block-end overhead (including the per-block l1-to-l2 root) post-flip (AZIP-22 Fast Inbox).
   // This is the real ceiling the proving system / L1 enforce — there is no explicit block-count cap.
   const blobBudget = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
   const maxBlocksThatFitInBlobs =
     1 +
     Math.floor(
-      (blobBudget - NUM_CHECKPOINT_END_MARKER_FIELDS - NUM_FIRST_BLOCK_END_BLOB_FIELDS) /
+      (blobBudget - NUM_CHECKPOINT_END_MARKER_FIELDS - NUM_BLOCK_END_BLOB_FIELDS) /
         (NUM_BLOCK_END_BLOB_FIELDS + MIN_TX_BLOB_FIELDS),
     );
 
@@ -42,7 +42,7 @@ describe('MAX_CAPACITY_BLOCKS_PER_CHECKPOINT', () => {
   it('matches the documented ceiling for the current blob constants', () => {
     // Pins the arithmetic so a change to BLOBS_PER_CHECKPOINT / FIELDS_PER_BLOB / block-field counts
     // is noticed and the constant + its comment get revisited.
-    expect(maxBlocksThatFitInBlobs).toBe(2457);
-    expect(MAX_CAPACITY_BLOCKS_PER_CHECKPOINT).toBe(2457);
+    expect(maxBlocksThatFitInBlobs).toBe(2234);
+    expect(MAX_CAPACITY_BLOCKS_PER_CHECKPOINT).toBe(2234);
   });
 });
diff --git a/yarn-project/stdlib/src/deserialization/index.ts b/yarn-project/stdlib/src/deserialization/index.ts
index fc5e693d9357..d132bce44df6 100644
--- a/yarn-project/stdlib/src/deserialization/index.ts
+++ b/yarn-project/stdlib/src/deserialization/index.ts
@@ -22,23 +22,23 @@ export const MAX_COMMITTEE_SIZE = 2048;
  *
  *   budget = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB = 6 * 4096 = 24,576 fields
  *
- *   per-block minimal blob footprint:
- *     first block  (may be empty)   = 7 fields   (NUM_FIRST_BLOCK_END_BLOB_FIELDS)
- *     every other  (needs >= 1 tx)  = 6 + 4 = 10 fields
+ *   per-block minimal blob footprint (every block carries the per-block l1-to-l2 root post-flip):
+ *     first block  (may be empty)   = 7 fields   (NUM_BLOCK_END_BLOB_FIELDS)
+ *     every other  (needs >= 1 tx)  = 7 + 4 = 11 fields
  *                                     (NUM_BLOCK_END_BLOB_FIELDS + a 4-field minimal tx:
  *                                      tx start marker + tx hash + fee + 1 mandatory nullifier)
  *     + 1 checkpoint-end marker      (NUM_CHECKPOINT_END_MARKER_FIELDS)
  *
- *   max N:  7 + 10*(N - 1) + 1 <= 24,576  =>  10*(N - 1) <= 24,568  =>  N <= 2,457
+ *   max N:  7 + 11*(N - 1) + 1 <= 24,576  =>  11*(N - 1) <= 24,568  =>  N <= 2,234
  *
  * Only the first block may be empty; every other block needs >= 1 tx (the circuits have no empty-tx
- * variant for non-first blocks), so 2457 is the largest provable checkpoint. The blob format can encode
- * more blocks than this (up to ~4095 with all-empty blocks), but such a checkpoint is unprovable and
+ * variant for non-first blocks), so 2234 is the largest provable checkpoint. The blob format can encode
+ * more blocks than this (up to ~3510 with all-empty blocks), but such a checkpoint is unprovable and
  * can only reach L1 with a malicious committee supermajority — a terminal network compromise where a
  * wedged archiver is an acceptable outcome. We therefore bound ingest to the provable maximum.
  * Invariant checked by the unit test in deserialization.test.ts.
  */
-export const MAX_CAPACITY_BLOCKS_PER_CHECKPOINT = 2457;
+export const MAX_CAPACITY_BLOCKS_PER_CHECKPOINT = 2234;
 
 /**
  * Max blocks per checkpoint we are willing to build or attest to (conservative client policy, and the
diff --git a/yarn-project/stdlib/src/gas/tx_gas_limits.test.ts b/yarn-project/stdlib/src/gas/tx_gas_limits.test.ts
index a6621bf28fef..0624244922a6 100644
--- a/yarn-project/stdlib/src/gas/tx_gas_limits.test.ts
+++ b/yarn-project/stdlib/src/gas/tx_gas_limits.test.ts
@@ -37,8 +37,7 @@ describe('computeNetworkTxGasLimits', () => {
           DA_GAS_PER_FIELD,
       );
       const firstBlockBlobFieldCap = Math.ceil(
-        ((BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS - getNumBlockEndBlobFields(true)) /
-          b) *
+        ((BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS - getNumBlockEndBlobFields()) / b) *
           MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER,
       );
       expect(admittedBlobFields).toBeLessThanOrEqual(firstBlockBlobFieldCap);
diff --git a/yarn-project/stdlib/src/gas/tx_gas_limits.ts b/yarn-project/stdlib/src/gas/tx_gas_limits.ts
index 17c00bfb8548..e73d8ed79c4c 100644
--- a/yarn-project/stdlib/src/gas/tx_gas_limits.ts
+++ b/yarn-project/stdlib/src/gas/tx_gas_limits.ts
@@ -1,8 +1,4 @@
-import {
-  NUM_BLOCK_END_BLOB_FIELDS,
-  NUM_CHECKPOINT_END_MARKER_FIELDS,
-  NUM_FIRST_BLOCK_END_BLOB_FIELDS,
-} from '@aztec/blob-lib/encoding';
+import { NUM_BLOCK_END_BLOB_FIELDS, NUM_CHECKPOINT_END_MARKER_FIELDS } from '@aztec/blob-lib/encoding';
 import {
   BLOBS_PER_CHECKPOINT,
   DA_GAS_PER_FIELD,
@@ -38,9 +34,8 @@ export const MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER = 1.5;
  * raw blob capacity (`BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB * DA_GAS_PER_FIELD`) minus the fields the blob
  * encoding reserves for overhead that no tx pays DA gas for:
  *
- * - one checkpoint-end marker field (`NUM_CHECKPOINT_END_MARKER_FIELDS`),
- * - the first block's block-end fields (`NUM_FIRST_BLOCK_END_BLOB_FIELDS`, 7), and
- * - `NUM_BLOCK_END_BLOB_FIELDS` (6) for each of the `blocks - 1` subsequent blocks.
+ * - one checkpoint-end marker field (`NUM_CHECKPOINT_END_MARKER_FIELDS`), and
+ * - `NUM_BLOCK_END_BLOB_FIELDS` (7, including the per-block l1-to-l2 root) for each of the `blocks` blocks.
  *
  * Subtracting the overhead for every block (not just the first) keeps the network DA admission limit at or
  * below the builder's first-block blob-field cap at every geometry. The builder is the MOST generous for the
@@ -57,10 +52,7 @@ export function getDaCheckpointBudgetForTxs(maxBlocksPerCheckpoint: number): num
   // raw blob capacity, which would otherwise yield a negative advertised DA budget.
   const fields = Math.max(
     0,
-    BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB -
-      NUM_CHECKPOINT_END_MARKER_FIELDS -
-      NUM_FIRST_BLOCK_END_BLOB_FIELDS -
-      (blocks - 1) * NUM_BLOCK_END_BLOB_FIELDS,
+    BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS - blocks * NUM_BLOCK_END_BLOB_FIELDS,
   );
   return fields * DA_GAS_PER_FIELD;
 }
diff --git a/yarn-project/validator-client/src/checkpoint_builder.test.ts b/yarn-project/validator-client/src/checkpoint_builder.test.ts
index afcca8d76564..b2d15dc392d8 100644
--- a/yarn-project/validator-client/src/checkpoint_builder.test.ts
+++ b/yarn-project/validator-client/src/checkpoint_builder.test.ts
@@ -297,8 +297,8 @@ describe('CheckpointBuilder', () => {
 
   describe('capLimitsByCheckpointBudgets (validator mode)', () => {
     const totalBlobCapacity = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
-    const firstBlockEndOverhead = getNumBlockEndBlobFields(true);
-    const nonFirstBlockEndOverhead = getNumBlockEndBlobFields(false);
+    const firstBlockEndOverhead = getNumBlockEndBlobFields();
+    const nonFirstBlockEndOverhead = getNumBlockEndBlobFields();
 
     it('caps L2 gas by remaining checkpoint mana', () => {
       const rollupManaLimit = 1_000_000;
diff --git a/yarn-project/validator-client/src/checkpoint_builder.ts b/yarn-project/validator-client/src/checkpoint_builder.ts
index 1083e1b7d7aa..b385f0074879 100644
--- a/yarn-project/validator-client/src/checkpoint_builder.ts
+++ b/yarn-project/validator-client/src/checkpoint_builder.ts
@@ -204,8 +204,7 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
     // Remaining blob fields (block blob fields include both tx data and block-end overhead)
     const usedBlobFields = sum(existingBlocks.map(b => b.toBlobFields().length));
     const totalBlobCapacity = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
-    const isFirstBlock = existingBlocks.length === 0;
-    const blockEndOverhead = getNumBlockEndBlobFields(isFirstBlock);
+    const blockEndOverhead = getNumBlockEndBlobFields();
     const maxBlobFieldsForTxs = totalBlobCapacity - usedBlobFields - blockEndOverhead;
 
     // Remaining txs

From 39873fdafe92ca0200a765dcc9f98410d0c243c1 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 10:34:28 -0300
Subject: [PATCH 04/22] feat(fast-inbox): drop the L1-to-L2 tree leaf-count
 multiple check (A-1384)

Post-flip the L1-to-L2 message tree grows by real message counts at compact
(unaligned) indices, so StateReference.validate no longer requires its
next-available leaf index to be a multiple of NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP
(AZIP-22 Fast Inbox). The per-tx partial-state checks are unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 yarn-project/stdlib/src/tx/state_reference.ts | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/yarn-project/stdlib/src/tx/state_reference.ts b/yarn-project/stdlib/src/tx/state_reference.ts
index 79a59204c7ac..d003ec0b2e6c 100644
--- a/yarn-project/stdlib/src/tx/state_reference.ts
+++ b/yarn-project/stdlib/src/tx/state_reference.ts
@@ -1,9 +1,4 @@
-import {
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-  STATE_REFERENCE_LENGTH,
-} from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, STATE_REFERENCE_LENGTH } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, BufferSink, FieldReader, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -106,14 +101,13 @@ export class StateReference {
   }
 
   /**
-   * Validates the trees in world state have the expected number of leaves (multiple of number of insertions per tx)
+   * Validates the partial-state trees have the expected number of leaves (multiple of number of insertions per tx).
+   *
+   * The L1-to-L2 message tree is not checked: post-flip it grows by real message counts at compact (unaligned)
+   * indices, so its next-available leaf index is no longer a multiple of any per-block subtree size (AZIP-22 Fast
+   * Inbox).
    */
   public validate() {
-    if (this.l1ToL2MessageTree.nextAvailableLeafIndex % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP !== 0) {
-      throw new Error(
-        `Invalid L1 to L2 message tree next available leaf index ${this.l1ToL2MessageTree.nextAvailableLeafIndex} (must be a multiple of ${NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP})`,
-      );
-    }
     if (this.partial.noteHashTree.nextAvailableLeafIndex % MAX_NOTE_HASHES_PER_TX !== 0) {
       throw new Error(
         `Invalid note hash tree next available leaf index ${this.partial.noteHashTree.nextAvailableLeafIndex} (must be a multiple of ${MAX_NOTE_HASHES_PER_TX})`,

From 0fc2cee692544f33a3f08153cc61309c04de1975 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 11:23:06 -0300
Subject: [PATCH 05/22] feat(fast-inbox): make streaming the only node
 consumption path (A-1384)

Remove the streamingInbox flag and wire streaming as the sole path (AZIP-22 Fast
Inbox):

- Config: drop streamingInbox from foundation env vars, stdlib sequencer/validator
  config + schemas, and the sequencer/validator config plumbing.
- Sequencer: source the parent checkpoint's consumed bucket from the fork's
  L1-to-L2 tree leaf count + getInboxBucketByTotalMsgCount (cross-checkpoint, not
  genesis-only); feed the header/block inHash zero; relax waitForMinTxs for
  message-only blocks; pass the consumed bucket seq as the propose bucketHint.
  Automine selects its single block's bundle the same way.
- Validator: per-block acceptance and checkpoint re-execution always run; the
  checkpoint rebuild derives the consumed message list from the buckets between the
  parent checkpoint's position and the last block.
- World state: appendL1ToL2MessagesToTree and handleL2BlockAndMessages append real
  leaves at compact indices; the synchronizer derives each block's bundle from its
  leaf-index range.
- Lightweight checkpoint builder feeds the checkpoint inHash zero.

Legacy bulk-fetch/insert paths go dead (deleted in FI-18). Verified via jest:
validator proposal_handler (34) + streaming checks (14), sequencer inbox selector
(9), world-state native (56). tsc rides CI.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 yarn-project/foundation/src/config/env_var.ts |   1 -
 .../light/lightweight_checkpoint_builder.ts   |   5 +-
 yarn-project/sequencer-client/src/config.ts   |   1 -
 .../src/publisher/sequencer-publisher.ts      |   5 +
 .../sequencer/automine/automine_sequencer.ts  |  50 +++++++--
 .../sequencer/checkpoint_proposal_job.test.ts |   3 +-
 .../src/sequencer/checkpoint_proposal_job.ts  | 100 +++++++++---------
 .../stdlib/src/config/sequencer-config.ts     |  10 --
 yarn-project/stdlib/src/interfaces/configs.ts |   8 --
 .../stdlib/src/interfaces/validator.ts        |   6 +-
 .../src/messaging/append_l1_to_l2_messages.ts |  18 +---
 yarn-project/validator-client/src/config.ts   |   8 +-
 .../src/proposal_handler.test.ts              |  12 +--
 .../validator-client/src/proposal_handler.ts  |  90 ++++++++--------
 .../src/native/native_world_state.test.ts     |  45 ++++----
 .../src/native/native_world_state.ts          |  21 ++--
 .../server_world_state_synchronizer.ts        |  46 +++++---
 yarn-project/world-state/src/test/utils.ts    |   8 +-
 18 files changed, 218 insertions(+), 219 deletions(-)

diff --git a/yarn-project/foundation/src/config/env_var.ts b/yarn-project/foundation/src/config/env_var.ts
index b4525a2c53a3..706ceae059ba 100644
--- a/yarn-project/foundation/src/config/env_var.ts
+++ b/yarn-project/foundation/src/config/env_var.ts
@@ -382,7 +382,6 @@ export type EnvVar =
   | 'FISHERMAN_MODE'
   | 'MAX_ALLOWED_ETH_CLIENT_DRIFT_SECONDS'
   | 'MAX_BLOCKS_PER_CHECKPOINT'
-  | 'STREAMING_INBOX'
   | 'LEGACY_BLS_CLI'
   | 'DEBUG_FORCE_TX_PROOF_VERIFICATION'
   | 'VALIDATOR_ALLOW_EPHEMERAL_SIGNING_PROTECTION'
diff --git a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
index 8a14968a9288..8d31ec7cbcb3 100644
--- a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
+++ b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
@@ -11,7 +11,6 @@ import {
   accumulateInboxRollingHash,
   appendL1ToL2MessagesToTree,
   computeCheckpointOutHash,
-  computeInHashFromL1ToL2Messages,
 } from '@aztec/stdlib/messaging';
 import { CheckpointHeader, computeBlockHeadersHash } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
@@ -295,7 +294,9 @@ export class LightweightCheckpointBuilder {
     const blobs = await getBlobsPerL1Block(this.blobFields);
     const blobsHash = computeBlobsHashFromBlobs(blobs);
 
-    const inHash = computeInHashFromL1ToL2Messages(this.l1ToL2Messages);
+    // Legacy inHash is dead post-flip; the checkpoint header carries zero (AZIP-22 Fast Inbox). The consensus
+    // rolling hash over the consumed messages is the authoritative Inbox commitment.
+    const inHash = Fr.ZERO;
     const inboxRollingHash = accumulateInboxRollingHash(this.previousInboxRollingHash, this.l1ToL2Messages);
 
     const { slotNumber, coinbase, feeRecipient, gasFees } = this.constants;
diff --git a/yarn-project/sequencer-client/src/config.ts b/yarn-project/sequencer-client/src/config.ts
index 90c22c71209d..09c73d6625f2 100644
--- a/yarn-project/sequencer-client/src/config.ts
+++ b/yarn-project/sequencer-client/src/config.ts
@@ -68,7 +68,6 @@ export const DefaultSequencerConfig = {
   skipPushProposedBlocksToArchiver: false,
   skipPublishingCheckpointsPercent: 0,
   maxBlocksPerCheckpoint: DEFAULT_MAX_BLOCKS_PER_CHECKPOINT,
-  streamingInbox: false,
 } satisfies ResolvedSequencerConfig;
 
 /**
diff --git a/yarn-project/sequencer-client/src/publisher/sequencer-publisher.ts b/yarn-project/sequencer-client/src/publisher/sequencer-publisher.ts
index 4c122580fe98..ea8091f4363e 100644
--- a/yarn-project/sequencer-client/src/publisher/sequencer-publisher.ts
+++ b/yarn-project/sequencer-client/src/publisher/sequencer-publisher.ts
@@ -113,6 +113,8 @@ type L1ProcessArgs = {
   attestationsAndSignersSignature: Signature;
   /** The fee asset price modifier in basis points (from oracle) */
   feeAssetPriceModifier: bigint;
+  /** Sequence number of the Inbox bucket the header's rolling hash corresponds to (AZIP-22 Fast Inbox lookup aid). */
+  bucketHint: bigint;
 };
 
 export const Actions = [
@@ -1404,6 +1406,7 @@ export class SequencerPublisher {
     checkpoint: Checkpoint,
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     attestationsAndSignersSignature: Signature,
+    bucketHint: bigint,
     opts: EnqueueProposeCheckpointOpts = {},
   ): Promise<void> {
     const checkpointHeader = checkpoint.header;
@@ -1418,6 +1421,7 @@ export class SequencerPublisher {
       attestationsAndSigners,
       attestationsAndSignersSignature,
       feeAssetPriceModifier: checkpoint.feeAssetPriceModifier,
+      bucketHint,
     };
 
     this.log.verbose(`Enqueuing checkpoint propose transaction`, {
@@ -1588,6 +1592,7 @@ export class SequencerPublisher {
         oracleInput: {
           feeAssetPriceModifier: encodedData.feeAssetPriceModifier,
         },
+        bucketHint: encodedData.bucketHint,
       },
       encodedData.attestationsAndSigners.getPackedAttestations(),
       signers,
diff --git a/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts b/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts
index 3c43860a8088..54e61084ecf1 100644
--- a/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts
+++ b/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts
@@ -1,7 +1,9 @@
 import type { Archiver } from '@aztec/archiver';
+import { INBOX_LAG_SECONDS, MAX_L1_TO_L2_MSGS_PER_BLOCK, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT } from '@aztec/constants';
 import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { type EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -22,8 +24,9 @@ import {
   getTimestampForSlot,
 } from '@aztec/stdlib/epoch-helpers';
 import { InsufficientValidTxsError, type WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { type L1ToL2MessageSource, getInboxCutoffTimestamp } from '@aztec/stdlib/messaging';
 import type { CoordinationSignatureContext } from '@aztec/stdlib/p2p';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { FailedTx, Tx } from '@aztec/stdlib/tx';
 import type {
   BuildBlockInCheckpointResult,
@@ -35,6 +38,7 @@ import type { GlobalVariableBuilder } from '../../global_variable_builder/global
 import type { SequencerPublisherFactory } from '../../publisher/sequencer-publisher-factory.js';
 import type { SequencerPublisher } from '../../publisher/sequencer-publisher.js';
 import type { SequencerConfig } from '../config.js';
+import { selectInboxBucketForBlock } from '../inbox_bucket_selector.js';
 
 /**
  * L1 rollup constants needed by the AutomineSequencer. Same as SequencerRollupConstants
@@ -447,8 +451,6 @@ export class AutomineSequencer {
       SlotNumber(targetSlot),
     );
 
-    const l1ToL2Messages = await this.deps.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
-
     const previousCheckpointOutHashes = await getPreviousCheckpointOutHashes({
       blockSource: this.deps.l2BlockSource,
       epoch: targetEpoch,
@@ -468,15 +470,40 @@ export class AutomineSequencer {
 
     await using fork = await this.deps.worldState.fork(syncedToBlockNumber, { closeDelayMs: 0 });
 
+    // Streaming Inbox (AZIP-22 Fast Inbox): automine builds a single-block checkpoint, so its one block is the
+    // checkpoint's final block; select its bundle from the newest lag-eligible bucket with the last-block censorship
+    // floor. The parent total is the fork's L1-to-L2 leaf count (compact indexing), which resolves the parent bucket.
+    const parentInfo = await fork.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+    const parentTotalMsgCount = parentInfo.size;
+    const parentBucket = await this.deps.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(parentTotalMsgCount);
+    if (parentBucket === undefined) {
+      this.log.warn(`Automine streaming inbox: parent bucket for total ${parentTotalMsgCount} not synced; skipping`);
+      return undefined;
+    }
+    const selection = await selectInboxBucketForBlock({
+      messageSource: this.deps.l1ToL2MessageSource,
+      now: BigInt(Math.floor(this.deps.dateProvider.now() / 1000)),
+      lagSeconds: BigInt(INBOX_LAG_SECONDS),
+      parent: { seq: parentBucket.seq, totalMsgCount: parentBucket.totalMsgCount },
+      checkpointStartTotalMsgCount: parentTotalMsgCount,
+      perBlockCap: MAX_L1_TO_L2_MSGS_PER_BLOCK,
+      perCheckpointCap: MAX_L1_TO_L2_MSGS_PER_CHECKPOINT,
+      isLastBlock: true,
+      cutoffTimestamp: getInboxCutoffTimestamp(SlotNumber(targetSlot), this.deps.l1Constants, INBOX_LAG_SECONDS),
+    });
+    const streamingBundle = selection.consume ? selection.bundle : [];
+    const bucketHint = selection.consume ? selection.bucket.seq : parentBucket.seq;
+
     const checkpointBuilder = await this.deps.checkpointsBuilder.startCheckpoint(
       checkpointNumber,
       checkpointGlobals,
       feeAssetPriceModifier,
-      l1ToL2Messages,
+      [],
       previousCheckpointOutHashes,
       previousInboxRollingHash,
       fork,
       this.log.getBindings(),
+      true,
     );
 
     // Block building only executes txs, and automine publishes straight to L1, so the proofs are never needed.
@@ -489,6 +516,7 @@ export class AutomineSequencer {
       checkpointGlobals.timestamp,
       allowEmpty,
       checkpointNumber,
+      streamingBundle,
     );
     if (!buildResult) {
       return undefined;
@@ -516,7 +544,12 @@ export class AutomineSequencer {
       feeAssetPriceModifier,
     });
 
-    await this.publisher.enqueueProposeCheckpoint(checkpoint, emptyAttestations, emptyAttestationsSignature);
+    await this.publisher.enqueueProposeCheckpoint(
+      checkpoint,
+      emptyAttestations,
+      emptyAttestationsSignature,
+      bucketHint,
+    );
     // Automine publishes synchronously in the current slot via `sendRequests`. It must NOT use the
     // production `sendRequestsAt` (or `canProposeAt`), which always apply the one-slot pipelining
     // offset — automine is the deliberate non-pipelined exception and builds/publishes in place.
@@ -756,16 +789,19 @@ export class AutomineSequencer {
     timestamp: bigint,
     allowEmpty: boolean,
     checkpointNumber: CheckpointNumber,
+    l1ToL2Messages: Fr[],
   ): Promise<BuildBlockInCheckpointResult | undefined> {
     let buildResult: BuildBlockInCheckpointResult;
     try {
       buildResult = await checkpointBuilder.buildBlock(pendingTxs, nextBlockNumber, timestamp, {
         maxTransactions: this.deps.config.maxTxsPerBlock,
-        // Allow empty for explicit-empty builds; require at least 1 valid tx otherwise.
-        minValidTxs: allowEmpty ? 0 : 1,
+        // Allow empty for explicit-empty builds; a message-only block (non-empty streaming bundle) also builds
+        // with zero txs.
+        minValidTxs: allowEmpty || l1ToL2Messages.length > 0 ? 0 : 1,
         isBuildingProposal: true,
         maxBlocksPerCheckpoint: 1,
         perBlockAllocationMultiplier: 1,
+        l1ToL2Messages,
       });
     } catch (err) {
       // Mirrors production's checkpoint_proposal_job: if every pending tx failed execution and
diff --git a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts
index 152ce2acdc00..33c9fb300a34 100644
--- a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts
+++ b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts
@@ -1394,10 +1394,9 @@ describe('CheckpointProposalJob', () => {
     });
   });
 
-  describe('streaming inbox (flag on)', () => {
+  describe('streaming inbox', () => {
     beforeEach(() => {
       job.setTimetable(makeProposerTimetable({ l1Constants, blockDurationMs: 3000 }));
-      job.updateConfig({ streamingInbox: true });
     });
 
     it('streams per-block bucket bundles, advances the reference, and skips the bulk message fetch', async () => {
diff --git a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
index b04b8da619c7..798edd6735b8 100644
--- a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
+++ b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
@@ -49,15 +49,11 @@ import { Gas } from '@aztec/stdlib/gas';
 import {
   type BlockBuilderOptions,
   InsufficientValidTxsError,
+  type MerkleTreeWriteOperations,
   type ResolvedSequencerConfig,
   type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
-import {
-  InboxBucketRef,
-  type L1ToL2MessageSource,
-  computeInHashFromL1ToL2Messages,
-  getInboxCutoffTimestamp,
-} from '@aztec/stdlib/messaging';
+import { InboxBucketRef, type L1ToL2MessageSource, getInboxCutoffTimestamp } from '@aztec/stdlib/messaging';
 import type {
   BlockProposal,
   BlockProposalOptions,
@@ -69,6 +65,7 @@ import type {
 import { orderAttestations, trimAttestations } from '@aztec/stdlib/p2p';
 import type { L2BlockBuiltStats } from '@aztec/stdlib/stats';
 import type { ProposerTimetable } from '@aztec/stdlib/timetable';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { type FailedTx, Tx } from '@aztec/stdlib/tx';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { Attributes, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
@@ -107,6 +104,8 @@ type CheckpointProposalResult = {
   checkpoint: Checkpoint;
   attestations: CommitteeAttestationsAndSigners;
   attestationsSignature: Signature;
+  /** Sequence number of the Inbox bucket the checkpoint's rolling hash corresponds to; the L1 `propose` lookup aid. */
+  bucketHint: bigint;
 };
 
 /**
@@ -120,8 +119,6 @@ type StreamingCheckpointState = {
   parent: ConsumedBucketCursor;
   /** Reference to the last consumed bucket; reused by blocks that consume nothing. */
   lastBucketRef: InboxBucketRef;
-  /** All message leaves consumed so far this checkpoint, in insertion order; drives the running `inHash`. */
-  accumulatedMessages: Fr[];
 };
 
 /**
@@ -313,6 +310,8 @@ export class CheckpointProposalJob implements Traceable {
     votesPromises: Promise<unknown>[],
   ): Promise<void> {
     const { checkpoint } = broadcast;
+    // The checkpoint's consumed Inbox bucket is the last block's bucket reference (undefined ⇒ genesis bucket 0).
+    const bucketHint = broadcast.proposal.bucketRef?.bucketSeq ?? 0n;
 
     try {
       // Wait for all votes actions, enqueued at the beginning, to resolve
@@ -324,7 +323,7 @@ export class CheckpointProposalJob implements Traceable {
       // Wait for the previous checkpoint to land on L1 before submitting, so we can check it
       // matches the proposed checkpoint we used as parent, and has valid attestations.
       if (signedAttestations && (await this.waitForValidParentCheckpointOnL1())) {
-        await this.enqueueCheckpointForSubmission({ checkpoint, ...signedAttestations });
+        await this.enqueueCheckpointForSubmission({ checkpoint, ...signedAttestations, bucketHint });
       }
 
       // If we failed to collect attestations, at least check if we need to issue an invalidation
@@ -395,7 +394,7 @@ export class CheckpointProposalJob implements Traceable {
 
   /** Enqueues the checkpoint for L1 submission. Called after pipeline sleep in execute(). */
   private async enqueueCheckpointForSubmission(result: CheckpointProposalResult): Promise<void> {
-    const { checkpoint, attestations, attestationsSignature } = result;
+    const { checkpoint, attestations, attestationsSignature, bucketHint } = result;
 
     this.setState(SequencerState.PUBLISHING_CHECKPOINT);
     // Latest L1 block the propose can still land in for the target slot: the last Ethereum block inside
@@ -424,7 +423,9 @@ export class CheckpointProposalJob implements Traceable {
       }
     }
 
-    await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, { txTimeoutAt });
+    await this.publisher.enqueueProposeCheckpoint(checkpoint, attestations, attestationsSignature, bucketHint, {
+      txTimeoutAt,
+    });
   }
 
   /**
@@ -637,14 +638,10 @@ export class CheckpointProposalJob implements Traceable {
         this.checkpointSimulationOverridesPlan,
       );
 
-      // Collect L1 to L2 messages for the checkpoint and compute their hash. Under the streaming Inbox (AZIP-22
-      // Fast Inbox) messages are selected per block instead, so the bulk fetch and up-front insertion are skipped
-      // and both start empty; the running values are computed block by block in the build loop.
-      const streamingInbox = this.config.streamingInbox;
-      const l1ToL2Messages = streamingInbox
-        ? []
-        : await this.l1ToL2MessageSource.getL1ToL2Messages(this.checkpointNumber);
-      const inHash = streamingInbox ? Fr.ZERO : computeInHashFromL1ToL2Messages(l1ToL2Messages);
+      // Under the streaming Inbox (AZIP-22 Fast Inbox) messages are selected per block, so the checkpoint-level bulk
+      // list stays empty and the legacy inHash is fed zero; the running values are computed block by block.
+      const l1ToL2Messages: Fr[] = [];
+      const inHash = Fr.ZERO;
 
       // Collect the out hashes of all the checkpoints before this one in the same epoch.
       // Under pipelining the parent checkpoint may not be on L1 yet at build time, so the helper
@@ -671,12 +668,6 @@ export class CheckpointProposalJob implements Traceable {
         log: this.log,
       });
 
-      // Streaming Inbox: resolve where this checkpoint's consumption starts (the parent checkpoint's last-consumed
-      // bucket). Only the genesis base case is wired here; see resolveStreamingCheckpointStart.
-      const streamingState = streamingInbox
-        ? await this.resolveStreamingCheckpointStart(previousInboxRollingHash)
-        : undefined;
-
       // Anchor the modifier to the predicted parent fee header: L1 will apply it against
       // that, not against the latest published checkpoint (which lags by one under pipelining).
       const predictedParentEthPerFeeAssetE12 =
@@ -686,6 +677,11 @@ export class CheckpointProposalJob implements Traceable {
       // Create a long-lived forked world state for the checkpoint builder
       await using fork = await this.worldState.fork(this.syncedToBlockNumber, { closeDelayMs: 12_000 });
 
+      // Streaming Inbox: the consumption cursor starts at the parent state this checkpoint builds on. The fork's
+      // L1-to-L2 tree leaf count is the parent's cumulative consumed total (compact indexing), which resolves the
+      // parent's last-consumed bucket.
+      const streamingState = await this.resolveStreamingCheckpointStart(fork);
+
       // Create checkpoint builder for the entire slot
       const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(
         this.checkpointNumber,
@@ -696,7 +692,7 @@ export class CheckpointProposalJob implements Traceable {
         previousInboxRollingHash,
         fork,
         this.log.getBindings(),
-        streamingInbox,
+        true,
       );
 
       // Options for the validator client when creating block and checkpoint proposals
@@ -1009,20 +1005,17 @@ export class CheckpointProposalJob implements Traceable {
       blocksInCheckpoint.push(block);
       usedTxs.forEach(tx => txHashesAlreadyIncluded.add(tx.txHash.toString()));
 
-      // Streaming Inbox: the block built successfully, so advance the consumption cursor and derive this block's
-      // rolling-hash bucket reference and `inHash`. A block that consumed nothing reuses the parent bucket
-      // reference; the running `inHash` over the accumulated messages matches the checkpoint header's `inHash`
-      // once the last block is reached.
-      let blockInHash = inHash;
+      // Streaming Inbox: the block built successfully, so advance the consumption cursor and carry this block's
+      // rolling-hash bucket reference. A block that consumed nothing reuses the parent bucket reference. The legacy
+      // inHash is dead post-flip; block proposals carry zero (AZIP-22 Fast Inbox).
+      const blockInHash = inHash;
       let blockBucketRef: InboxBucketRef | undefined = undefined;
       if (streamingState && selection) {
         if (selection.consume) {
           streamingState.parent = { seq: selection.bucket.seq, totalMsgCount: selection.bucket.totalMsgCount };
           streamingState.lastBucketRef = InboxBucketRef.fromBucket(selection.bucket);
-          streamingState.accumulatedMessages.push(...selection.bundle);
         }
         blockBucketRef = streamingState.lastBucketRef;
-        blockInHash = computeInHashFromL1ToL2Messages(streamingState.accumulatedMessages);
       }
 
       // Sign the block proposal. This will throw if HA signing fails.
@@ -1101,25 +1094,25 @@ export class CheckpointProposalJob implements Traceable {
 
   /**
    * Resolves where a streaming-Inbox checkpoint's consumption starts: the parent checkpoint's last-consumed bucket
-   * (AZIP-22 Fast Inbox). Only the genesis base case is wired: when the parent's rolling hash is zero, consumption
-   * begins from the start of the Inbox. Sourcing a non-genesis parent's bucket needs the consumed reference carried
-   * across checkpoints (there is no by-rolling-hash archiver lookup, and legacy parents do not sit on a bucket
-   * boundary); that is a flip-time concern. Pre-flip the flag is off, so this throw only fires if the flag is turned
-   * on against a non-genesis chain, where the outer catch turns it into a skipped (unsubmitted) proposal.
+   * (AZIP-22 Fast Inbox). The parent's cumulative consumed total is the L1-to-L2 message tree leaf count of the fork
+   * this checkpoint builds on (compact indexing makes leaf count equal cumulative message count), which resolves the
+   * parent bucket by total. Genesis is the `total = 0` case, resolving the genesis bucket 0.
    */
-  private resolveStreamingCheckpointStart(previousInboxRollingHash: Fr): Promise<StreamingCheckpointState> {
-    if (!previousInboxRollingHash.isZero()) {
+  private async resolveStreamingCheckpointStart(fork: MerkleTreeWriteOperations): Promise<StreamingCheckpointState> {
+    const parentInfo = await fork.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+    const parentTotalMsgCount = parentInfo.size;
+    const parentBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(parentTotalMsgCount);
+    if (parentBucket === undefined) {
       throw new Error(
-        `Streaming inbox: cannot source parent checkpoint bucket for non-genesis rolling hash ${previousInboxRollingHash} ` +
-          `(checkpoint ${this.checkpointNumber}); cross-checkpoint streaming is wired at the flip`,
+        `Streaming inbox: cannot resolve parent Inbox bucket for cumulative total ${parentTotalMsgCount} ` +
+          `(checkpoint ${this.checkpointNumber}); local Inbox view has not synced it`,
       );
     }
-    return Promise.resolve({
-      checkpointStartTotalMsgCount: 0n,
-      parent: { seq: 0n, totalMsgCount: 0n },
-      lastBucketRef: InboxBucketRef.empty(),
-      accumulatedMessages: [],
-    });
+    return {
+      checkpointStartTotalMsgCount: parentTotalMsgCount,
+      parent: { seq: parentBucket.seq, totalMsgCount: parentBucket.totalMsgCount },
+      lastBucketRef: InboxBucketRef.fromBucket(parentBucket),
+    };
   }
 
   /**
@@ -1385,11 +1378,18 @@ export class CheckpointProposalJob implements Traceable {
     blockNumber: BlockNumber;
     indexWithinCheckpoint: IndexWithinCheckpoint;
     buildDeadline: Date | undefined;
+    /** Streaming Inbox message bundle this block consumes; a non-empty bundle permits a zero-tx (message-only) block. */
+    l1ToL2Messages?: Fr[];
   }): Promise<{ canStartBuilding: boolean; minTxs: number }> {
     const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
 
-    // We only allow a block with 0 txs in the first block of the checkpoint
-    const minTxs = indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 ? 1 : this.config.minTxsPerBlock;
+    // A non-first block normally needs >= 1 tx to avoid empty filler blocks, but a message-only block (a non-empty
+    // streaming Inbox bundle) may carry zero txs (AZIP-22 Fast Inbox).
+    const hasStreamingBundle = (opts.l1ToL2Messages?.length ?? 0) > 0;
+    const minTxs =
+      indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 && !hasStreamingBundle
+        ? 1
+        : this.config.minTxsPerBlock;
 
     // Latest time to keep waiting for txs: wait_for_txs_deadline = block_build_deadline(k) - min_block_duration.
     const startBuildingDeadline = buildDeadline
diff --git a/yarn-project/stdlib/src/config/sequencer-config.ts b/yarn-project/stdlib/src/config/sequencer-config.ts
index 874d2449bd20..f08782c1ef54 100644
--- a/yarn-project/stdlib/src/config/sequencer-config.ts
+++ b/yarn-project/stdlib/src/config/sequencer-config.ts
@@ -1,6 +1,5 @@
 import {
   type ConfigMappingsType,
-  booleanConfigHelper,
   floatConfigHelper,
   numberConfigHelper,
   optionalNumberConfigHelper,
@@ -41,7 +40,6 @@ export const sharedSequencerConfigMappings: ConfigMappingsType<
     | 'checkpointProposalPrepareTime'
     | 'minBlockDuration'
     | 'maxBlocksPerCheckpoint'
-    | 'streamingInbox'
   >
 > = {
   blockDurationMs: {
@@ -95,12 +93,4 @@ export const sharedSequencerConfigMappings: ConfigMappingsType<
     parseEnv: (val: string) => parseInt(val, 10),
     defaultValue: DEFAULT_MAX_BLOCKS_PER_CHECKPOINT,
   },
-  streamingInbox: {
-    env: 'STREAMING_INBOX',
-    description:
-      'Select L1-to-L2 messages per block from the streaming Inbox buckets (AZIP-22 Fast Inbox) instead of the whole ' +
-      "checkpoint's messages up front. Shared by the sequencer and validator, which must flip together. Default off: " +
-      'pre-flip a checkpoint built with this on is expected to fail L1 submission.',
-    ...booleanConfigHelper(false),
-  },
 };
diff --git a/yarn-project/stdlib/src/interfaces/configs.ts b/yarn-project/stdlib/src/interfaces/configs.ts
index 28c24922a938..14602960be57 100644
--- a/yarn-project/stdlib/src/interfaces/configs.ts
+++ b/yarn-project/stdlib/src/interfaces/configs.ts
@@ -110,13 +110,6 @@ export interface SequencerConfig {
   expectedBlockProposalsPerSlot?: number;
   /** Have sequencer build and publish an empty checkpoint if there are no txs */
   buildCheckpointIfEmpty?: boolean;
-  /**
-   * Select L1-to-L2 messages per block from the streaming Inbox buckets (AZIP-22 Fast Inbox), rather than consuming
-   * the whole checkpoint's messages up front. Default off: pre-flip, on-chain `propose` still enforces the legacy
-   * per-checkpoint consumption, so a checkpoint built with this on is expected to fail L1 submission. The sequencer
-   * and validator must flip together, so both read the same `STREAMING_INBOX` env var.
-   */
-  streamingInbox?: boolean;
   /** Skip pushing proposed blocks to archiver (default: false) */
   skipPushProposedBlocksToArchiver?: boolean;
   /** Minimum number of blocks required for a checkpoint proposal (test only, defaults to undefined = no minimum) */
@@ -181,7 +174,6 @@ export const SequencerConfigSchema = zodFor<SequencerConfig>()(
     checkpointProposalSyncGraceSeconds: z.number().nonnegative().optional(),
     expectedBlockProposalsPerSlot: z.number().nonnegative().optional(),
     buildCheckpointIfEmpty: z.boolean().optional(),
-    streamingInbox: z.boolean().optional(),
     skipPushProposedBlocksToArchiver: z.boolean().optional(),
     minBlocksForCheckpoint: z.number().positive().optional(),
     skipPublishingCheckpointsPercent: z.number().gte(0).lte(100).optional(),
diff --git a/yarn-project/stdlib/src/interfaces/validator.ts b/yarn-project/stdlib/src/interfaces/validator.ts
index a7d1ae245daf..f17e96e2a475 100644
--- a/yarn-project/stdlib/src/interfaces/validator.ts
+++ b/yarn-project/stdlib/src/interfaces/validator.ts
@@ -83,10 +83,7 @@ export type ValidatorClientConfig = ValidatorHASignerConfig &
   };
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
-  Pick<
-    SequencerConfig,
-    'txPublicSetupAllowListExtend' | 'broadcastInvalidBlockProposal' | 'maxBlocksPerCheckpoint' | 'streamingInbox'
-  > &
+  Pick<SequencerConfig, 'txPublicSetupAllowListExtend' | 'broadcastInvalidBlockProposal' | 'maxBlocksPerCheckpoint'> &
   // `blockDurationMs` is optional on the loose `SequencerConfig` but is always populated via the shared
   // `numberConfigHelper(3000)` mapping, so it is required on the fully-resolved validator config.
   Required<Pick<SequencerConfig, 'blockDurationMs'>> &
@@ -137,7 +134,6 @@ export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullCo
     broadcastInvalidBlockProposal: z.boolean().optional(),
     blockDurationMs: z.number().positive(),
     maxBlocksPerCheckpoint: z.number().positive().optional(),
-    streamingInbox: z.boolean().optional(),
     slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
     slashBroadcastedInvalidCheckpointProposalPenalty: schemas.BigInt,
     slashDuplicateProposalPenalty: schemas.BigInt,
diff --git a/yarn-project/stdlib/src/messaging/append_l1_to_l2_messages.ts b/yarn-project/stdlib/src/messaging/append_l1_to_l2_messages.ts
index 31f53fd47c03..2090e0a164c1 100644
--- a/yarn-project/stdlib/src/messaging/append_l1_to_l2_messages.ts
+++ b/yarn-project/stdlib/src/messaging/append_l1_to_l2_messages.ts
@@ -1,21 +1,13 @@
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { MerkleTreeWriteOperations } from '../interfaces/merkle_tree_operations.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 
 /**
- * Pads `l1ToL2Messages` to `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` and appends them to the
- * L1→L2 message tree of `db`. Use whenever a fork at "state before the first block of a
- * checkpoint" needs to mirror what the world-state synchronizer inserts at sync time.
+ * Appends a block's real L1→L2 message leaves (unpadded, at compact indices) to the L1→L2 message tree of `db`
+ * (AZIP-22 Fast Inbox). Use whenever a fork at "state before a block" needs to mirror what the world-state
+ * synchronizer inserts at sync time.
  */
 export async function appendL1ToL2MessagesToTree(db: MerkleTreeWriteOperations, l1ToL2Messages: Fr[]): Promise<void> {
-  const padded = padArrayEnd<Fr, number>(
-    l1ToL2Messages,
-    Fr.ZERO,
-    NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-    'Too many L1 to L2 messages',
-  );
-  await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padded);
+  await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
 }
diff --git a/yarn-project/validator-client/src/config.ts b/yarn-project/validator-client/src/config.ts
index 6b130b40190f..8237ab2664a3 100644
--- a/yarn-project/validator-client/src/config.ts
+++ b/yarn-project/validator-client/src/config.ts
@@ -21,9 +21,9 @@ export type { ValidatorClientConfig };
 export const DEFAULT_MAX_GOSSIP_CLOCK_DISPARITY_MS = 500;
 
 export const validatorClientConfigMappings: ConfigMappingsType<
-  ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs' | 'streamingInbox'>
+  ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'>
 > = {
-  ...pickConfigMappings(sharedSequencerConfigMappings, ['blockDurationMs', 'streamingInbox']),
+  ...pickConfigMappings(sharedSequencerConfigMappings, ['blockDurationMs']),
   validatorPrivateKeys: {
     env: 'VALIDATOR_PRIVATE_KEYS',
     description: 'List of private keys of the validators participating in attestation duties',
@@ -124,8 +124,8 @@ export const validatorClientConfigMappings: ConfigMappingsType<
  * @returns The validator configuration.
  */
 export function getProverEnvVars(): ValidatorClientConfig &
-  Pick<SequencerConfig, 'blockDurationMs' | 'streamingInbox'> {
-  return getConfigFromMappings<ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs' | 'streamingInbox'>>(
+  Pick<SequencerConfig, 'blockDurationMs'> {
+  return getConfigFromMappings<ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'>>(
     validatorClientConfigMappings,
   );
 }
diff --git a/yarn-project/validator-client/src/proposal_handler.test.ts b/yarn-project/validator-client/src/proposal_handler.test.ts
index 76f32c151693..f6176a40bef1 100644
--- a/yarn-project/validator-client/src/proposal_handler.test.ts
+++ b/yarn-project/validator-client/src/proposal_handler.test.ts
@@ -498,7 +498,10 @@ describe('ProposalHandler checkpoint validation', () => {
         archive: new AppendOnlyTreeSnapshot(archiveRoot, 1),
         number: 1,
         checkpointNumber: CheckpointNumber(1),
-        header: { globalVariables: GlobalVariables.empty({ slotNumber: SlotNumber(1) }) },
+        header: {
+          globalVariables: GlobalVariables.empty({ slotNumber: SlotNumber(1) }),
+          state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 0 } },
+        },
       } as unknown as L2Block;
 
       blockSource.getBlockData.mockResolvedValue({ header: makeBlockHeader() } as BlockData);
@@ -775,7 +778,7 @@ describe('ProposalHandler checkpoint validation', () => {
         blockProposalValidator,
         epochCache,
         consensusTimetable,
-        { ...config, streamingInbox: true } as ValidatorClientFullConfig,
+        config,
         mock<BlobClientInterface>(),
         new CheckpointReexecutionTracker(),
         metrics,
@@ -832,7 +835,7 @@ describe('ProposalHandler checkpoint validation', () => {
       const result = await blockHandler.handleBlockProposal(proposal, {} as any, true);
 
       expect(result.isValid).toBe(true);
-      // The block re-executes with the derived per-block bundle and the streaming flag set.
+      // The block re-executes with the derived per-block bundle (streaming is the only path post-flip).
       expect(reexecuteSpy).toHaveBeenCalledWith(
         proposal,
         BlockNumber(INITIAL_L2_BLOCK_NUM),
@@ -841,7 +844,6 @@ describe('ProposalHandler checkpoint validation', () => {
         derivedBundle,
         expect.anything(),
         expect.anything(),
-        true,
       );
     });
   });
@@ -884,7 +886,6 @@ describe('ProposalHandler checkpoint validation', () => {
     }
 
     it('refuses to attest when a mandatory bucket (at or before the cutoff) is left unconsumed', async () => {
-      config = { ...config, streamingInbox: true } as ValidatorClientFullConfig;
       handler.updateConfig(config);
       const { archiveRoot } = setupCensorshipMocks(2);
       // cutoff(slot=10) with l1GenesisTime=0, slotDuration=24, lag=12 is (10-1)*24 - 12 = 204.
@@ -909,7 +910,6 @@ describe('ProposalHandler checkpoint validation', () => {
     });
 
     it('does not reject on censorship when the first unconsumed bucket is past the cutoff', async () => {
-      config = { ...config, streamingInbox: true } as ValidatorClientFullConfig;
       handler.updateConfig(config);
       const { archiveRoot } = setupCensorshipMocks(2);
       l1ToL2MessageSource.getInboxBucketByTotalMsgCount.mockResolvedValue({
diff --git a/yarn-project/validator-client/src/proposal_handler.ts b/yarn-project/validator-client/src/proposal_handler.ts
index c12de5df3966..4abf8bb64ac5 100644
--- a/yarn-project/validator-client/src/proposal_handler.ts
+++ b/yarn-project/validator-client/src/proposal_handler.ts
@@ -38,7 +38,6 @@ import type { ITxProvider, ValidatorClientFullConfig, WorldStateSynchronizer } f
 import {
   type L1ToL2MessageSource,
   accumulateCheckpointOutHashes,
-  computeInHashFromL1ToL2Messages,
   getInboxCutoffTimestamp,
   isInboxConsumptionSufficient,
 } from '@aztec/stdlib/messaging';
@@ -69,7 +68,7 @@ export type BlockProposalValidationFailureReason =
   | 'parent_block_not_found'
   | 'parent_block_wrong_slot'
   | 'in_hash_mismatch'
-  // Streaming Inbox (AZIP-22 Fast Inbox) per-block acceptance failures, gated behind `streamingInbox`.
+  // Streaming Inbox (AZIP-22 Fast Inbox) per-block acceptance failures.
   | StreamingBlockCheckReason
   | 'global_variables_mismatch'
   | 'block_number_already_exists'
@@ -116,7 +115,7 @@ export type CheckpointProposalValidationFailureReason =
   | 'checkpoint_header_mismatch'
   | 'archive_mismatch'
   | 'out_hash_mismatch'
-  // Streaming Inbox (AZIP-22 Fast Inbox) last-block censorship failure, gated behind `streamingInbox`.
+  // Streaming Inbox (AZIP-22 Fast Inbox) last-block censorship failure.
   | 'inbox_consumption_insufficient'
   | 'checkpoint_validation_failed';
 
@@ -564,37 +563,18 @@ export class ProposalHandler {
     const checkpointNumber = checkpointResult.checkpointNumber;
     proposalInfo.checkpointNumber = checkpointNumber;
 
-    // Resolve this block's L1-to-L2 message bundle. Under the streaming Inbox (AZIP-22 Fast Inbox) the block consumes
-    // a per-block bundle derived from its proposal bucket reference, gated by the four acceptance checks; the legacy
-    // flow compares the whole checkpoint's `inHash` and inserts all its messages up front. Flag off ⇒ byte-identical
-    // to before.
-    const streamingInbox = this.config.streamingInbox === true;
-    let l1ToL2Messages: Fr[];
-    if (streamingInbox) {
-      const streamingResult = await this.runStreamingBlockChecks(proposal, blockNumber, parentBlock);
-      if (!streamingResult.accepted) {
-        this.log.warn(`Streaming Inbox block acceptance check failed, skipping processing`, {
-          reason: streamingResult.reason,
-          bucketRef: proposal.bucketRef?.toInspect(),
-          ...proposalInfo,
-        });
-        return { isValid: false, blockNumber, reason: streamingResult.reason };
-      }
-      l1ToL2Messages = streamingResult.bundle;
-    } else {
-      // Check that I have the same set of l1ToL2Messages as the proposal
-      l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
-      const computedInHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
-      const proposalInHash = proposal.inHash;
-      if (!computedInHash.equals(proposalInHash)) {
-        this.log.warn(`L1 to L2 messages in hash mismatch, skipping processing`, {
-          proposalInHash: proposalInHash.toString(),
-          computedInHash: computedInHash.toString(),
-          ...proposalInfo,
-        });
-        return { isValid: false, blockNumber, reason: 'in_hash_mismatch' };
-      }
+    // Resolve this block's L1-to-L2 message bundle from its proposal bucket reference, gated by the four streaming
+    // acceptance checks (AZIP-22 Fast Inbox).
+    const streamingResult = await this.runStreamingBlockChecks(proposal, blockNumber, parentBlock);
+    if (!streamingResult.accepted) {
+      this.log.warn(`Streaming Inbox block acceptance check failed, skipping processing`, {
+        reason: streamingResult.reason,
+        bucketRef: proposal.bucketRef?.toInspect(),
+        ...proposalInfo,
+      });
+      return { isValid: false, blockNumber, reason: streamingResult.reason };
     }
+    const l1ToL2Messages = streamingResult.bundle;
 
     // Check that all of the transactions in the proposal are available
     if (missingTxs.length > 0) {
@@ -633,7 +613,6 @@ export class ProposalHandler {
         l1ToL2Messages,
         previousCheckpointOutHashes,
         previousInboxRollingHash,
-        streamingInbox,
       );
     } catch (error) {
       this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
@@ -1011,6 +990,25 @@ export class ProposalHandler {
     });
   }
 
+  /**
+   * Derives the ordered list of L1-to-L2 messages a checkpoint consumed across its blocks, from the Inbox buckets
+   * between the parent checkpoint's consumed position and the checkpoint's last block (AZIP-22 Fast Inbox). Empty when
+   * the checkpoint consumed nothing or its consumption cannot be resolved against the local Inbox view.
+   */
+  private async deriveCheckpointConsumedMessages(blocks: L2Block[]): Promise<Fr[]> {
+    const checkpointStartTotal = await this.getPreBlockConsumedTotal(blocks[0].number);
+    const lastBlockTotal = this.blockLeafCount(blocks[blocks.length - 1]);
+    if (checkpointStartTotal === undefined || lastBlockTotal <= checkpointStartTotal) {
+      return [];
+    }
+    const startBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(checkpointStartTotal);
+    const endBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(lastBlockTotal);
+    if (startBucket === undefined || endBucket === undefined) {
+      return [];
+    }
+    return this.l1ToL2MessageSource.getL1ToL2MessagesBetweenBuckets(startBucket.seq, endBucket.seq);
+  }
+
   async reexecuteTransactions(
     proposal: BlockProposal,
     blockNumber: BlockNumber,
@@ -1019,9 +1017,6 @@ export class ProposalHandler {
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
     previousInboxRollingHash: Fr,
-    // Streaming Inbox (AZIP-22 Fast Inbox): when true, `l1ToL2Messages` is this block's per-block bundle, inserted
-    // into the fork during `buildBlock` rather than the whole checkpoint's messages up front.
-    streamingInbox: boolean = false,
   ): Promise<ReexecuteTransactionsResult> {
     const { blockHeader, txHashes } = proposal;
 
@@ -1063,19 +1058,19 @@ export class ProposalHandler {
       gasFees: blockHeader.globalVariables.gasFees,
     };
 
-    // Create checkpoint builder with prior blocks. Under the streaming Inbox the checkpoint-wide message list is empty
-    // and this block's bundle is inserted per block (below); the legacy flow inserts the whole checkpoint up front.
+    // Create checkpoint builder with prior blocks. Under the streaming Inbox (AZIP-22 Fast Inbox) the checkpoint-wide
+    // message list is empty and this block's bundle is inserted per block (below).
     const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(
       checkpointNumber,
       constants,
       0n, // only takes effect in the following checkpoint.
-      streamingInbox ? [] : l1ToL2Messages,
+      [],
       previousCheckpointOutHashes,
       previousInboxRollingHash,
       fork,
       priorBlocks,
       this.log.getBindings(),
-      streamingInbox,
+      true,
     );
 
     // Build the new block
@@ -1091,7 +1086,7 @@ export class ProposalHandler {
       expectedEndState: blockHeader.state,
       maxTransactions: this.config.validateMaxTxsPerBlock,
       maxBlockGas,
-      l1ToL2Messages: streamingInbox ? l1ToL2Messages : undefined,
+      l1ToL2Messages,
     });
 
     const { block, failedTxs } = result;
@@ -1303,9 +1298,8 @@ export class ProposalHandler {
     const checkpointNumber = firstBlock.checkpointNumber;
 
     // Streaming Inbox (AZIP-22 Fast Inbox): on the last block of a checkpoint, enforce the minimum-consumption
-    // (censorship) rule before attesting. Reject (no attestation) if a mandatory bucket was left unconsumed. Flag off,
-    // this is skipped and behavior is byte-identical.
-    if (this.config.streamingInbox === true && !(await this.isLastBlockConsumptionSufficient(slot, blocks))) {
+    // (censorship) rule before attesting. Reject (no attestation) if a mandatory bucket was left unconsumed.
+    if (!(await this.isLastBlockConsumptionSufficient(slot, blocks))) {
       this.log.warn(`Streaming Inbox last-block censorship check failed, refusing to attest`, {
         ...proposalInfo,
         checkpointNumber,
@@ -1313,8 +1307,10 @@ export class ProposalHandler {
       return { isValid: false, reason: 'inbox_consumption_insufficient', checkpointNumber };
     }
 
-    // Get L1-to-L2 messages for this checkpoint
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+    // Derive the checkpoint's consumed L1-to-L2 message list from the Inbox buckets between the parent checkpoint's
+    // consumed position and the last block's (compact indexing). The messages are already in the db from per-block
+    // validation; this list only drives the checkpoint's rolling-hash recomputation in completeCheckpoint.
+    const l1ToL2Messages = await this.deriveCheckpointConsumedMessages(blocks);
 
     // Collect the out hashes of all the checkpoints before this one in the same epoch.
     // See note on the analogous block-proposal site: the helper handles pipelining lag.
diff --git a/yarn-project/world-state/src/native/native_world_state.test.ts b/yarn-project/world-state/src/native/native_world_state.test.ts
index e2b4748488aa..e5d579c5e434 100644
--- a/yarn-project/world-state/src/native/native_world_state.test.ts
+++ b/yarn-project/world-state/src/native/native_world_state.test.ts
@@ -86,7 +86,7 @@ describe('NativeWorldState', () => {
       await ws.close();
     });
 
-    it('pads messages, note hashes, nullifiers correctly for first block', async () => {
+    it('appends messages unpadded and pads note hashes, nullifiers for first block', async () => {
       const isFirstBlock = true;
       const txsPerBlock = 2;
       const maxEffects = 1;
@@ -102,7 +102,8 @@ describe('NativeWorldState', () => {
 
       const status = await ws.handleL2BlockAndMessages(block, messages);
 
-      expect(status.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+      // Messages are appended unpadded at compact indices (AZIP-22 Fast Inbox).
+      expect(status.meta.messageTreeMeta.size).toBe(BigInt(numMessages));
 
       const expectedNoteHashCount = txsPerBlock * MAX_NOTE_HASHES_PER_TX;
       expect(status.meta.noteHashTreeMeta.size).toBe(BigInt(expectedNoteHashCount));
@@ -147,13 +148,13 @@ describe('NativeWorldState', () => {
       expect(status.meta.publicDataTreeMeta.size).toBe(BigInt(INITIAL_PUBLIC_DATA_TREE_SIZE + expectedPublicDataCount));
     });
 
-    it('pads empty messages array for first block', async () => {
+    it('leaves the message tree empty for a first block with no messages', async () => {
       const isFirstBlock = true;
       const numMessages = 0;
       const { block, messages } = await mockBlock(BlockNumber(1), 1, fork, 1, numMessages, isFirstBlock);
 
       const status = await ws.handleL2BlockAndMessages(block, messages);
-      expect(status.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+      expect(status.meta.messageTreeMeta.size).toBe(0n);
     });
 
     it('appends a non-first block bundle without padding', async () => {
@@ -188,18 +189,17 @@ describe('NativeWorldState', () => {
     it('advances the L1-to-L2 message tree per block, including on non-first blocks', async () => {
       const fork = await ws.fork();
 
-      // Block 1 is first-in-checkpoint, so its bundle is padded to NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP (this is how
-      // the circuits build the tree).
+      // Block 1 is first-in-checkpoint carrying 3 messages, appended unpadded at compact indices (AZIP-22 Fast Inbox).
       const { block: b1, messages: m1 } = await mockBlockWithIndex(BlockNumber(1), /*index=*/ 0, 1, fork, 3, 1);
       const s1 = await ws.handleL2BlockAndMessages(b1, m1);
-      expect(s1.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+      expect(s1.meta.messageTreeMeta.size).toBe(3n);
       expect(s1.meta.messageTreeMeta.unfinalizedBlockHeight).toBe(1);
 
       // Block 2 is non-first and carries no messages: the message tree size and root are unchanged, but the tree is
       // still committed as a new block (so its per-block history stays in lockstep with the other trees).
       const { block: b2, messages: m2 } = await mockBlockWithIndex(BlockNumber(2), /*index=*/ 1, 1, fork, 0, 1);
       const s2 = await ws.handleL2BlockAndMessages(b2, m2);
-      expect(s2.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+      expect(s2.meta.messageTreeMeta.size).toBe(3n);
       expect(s2.meta.messageTreeMeta.root).toEqual(s1.meta.messageTreeMeta.root);
       expect(s2.meta.messageTreeMeta.unfinalizedBlockHeight).toBe(2);
 
@@ -207,23 +207,19 @@ describe('NativeWorldState', () => {
       // bundle size and the root changes on a non-first block.
       const { block: b3, messages: m3 } = await mockBlockWithIndex(BlockNumber(3), /*index=*/ 2, 1, fork, 5, 1);
       const s3 = await ws.handleL2BlockAndMessages(b3, m3);
-      expect(s3.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP + 5));
+      expect(s3.meta.messageTreeMeta.size).toBe(8n);
       expect(s3.meta.messageTreeMeta.root).not.toEqual(s2.meta.messageTreeMeta.root);
       expect(s3.meta.messageTreeMeta.unfinalizedBlockHeight).toBe(3);
 
       await fork.close();
 
-      // A fork opened at block 2 sees exactly the first two bundles (3 padded + 0); at block 3 it also sees the third.
+      // A fork opened at block 2 sees exactly the first two bundles (3 + 0); at block 3 it also sees the third.
       const forkAt2 = await ws.fork(BlockNumber(2));
-      expect((await forkAt2.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE)).size).toBe(
-        BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
-      );
+      expect((await forkAt2.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE)).size).toBe(3n);
       await forkAt2.close();
 
       const forkAt3 = await ws.fork(BlockNumber(3));
-      expect((await forkAt3.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE)).size).toBe(
-        BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP + 5),
-      );
+      expect((await forkAt3.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE)).size).toBe(8n);
       await forkAt3.close();
     });
 
@@ -236,12 +232,12 @@ describe('NativeWorldState', () => {
       // Non-first block carrying 4 messages.
       const { block: b2, messages: m2 } = await mockBlockWithIndex(BlockNumber(2), /*index=*/ 1, 1, fork, 4, 1);
       const s2 = await ws.handleL2BlockAndMessages(b2, m2);
-      expect(s2.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP + 4));
+      expect(s2.meta.messageTreeMeta.size).toBe(6n);
 
       // Non-first block carrying 5 messages.
       const { block: b3, messages: m3 } = await mockBlockWithIndex(BlockNumber(3), /*index=*/ 2, 1, fork, 5, 1);
       const s3 = await ws.handleL2BlockAndMessages(b3, m3);
-      expect(s3.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP + 9));
+      expect(s3.meta.messageTreeMeta.size).toBe(11n);
       await fork.close();
 
       // Unwind block 3: the message tree returns to the post-block-2 state.
@@ -259,23 +255,22 @@ describe('NativeWorldState', () => {
       const resyncFork = await ws.fork();
       const { block: b2b, messages: m2b } = await mockBlockWithIndex(BlockNumber(2), /*index=*/ 1, 1, resyncFork, 4, 1);
       const s2b = await ws.handleL2BlockAndMessages(b2b, m2b);
-      expect(s2b.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP + 4));
+      expect(s2b.meta.messageTreeMeta.size).toBe(6n);
 
       const { block: b3b, messages: m3b } = await mockBlockWithIndex(BlockNumber(3), /*index=*/ 2, 1, resyncFork, 5, 1);
       const s3b = await ws.handleL2BlockAndMessages(b3b, m3b);
-      expect(s3b.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP + 9));
+      expect(s3b.meta.messageTreeMeta.size).toBe(11n);
       await resyncFork.close();
     });
 
-    it('leaves the message tree byte-identical on every non-first block of a legacy-shaped checkpoint', async () => {
+    it('leaves the message tree unchanged on every non-first block that carries no messages', async () => {
       const fork = await ws.fork();
 
-      // Legacy call shape: the whole (padded) checkpoint bundle is attached to the first block; non-first blocks carry
-      // an empty bundle. With this shape the code change is a no-op, so the message tree must match the pre-change
-      // behaviour (identical trees) at every block, not just at the checkpoint end.
+      // A checkpoint whose messages are all consumed by its first block: non-first blocks carry an empty bundle, so the
+      // message tree must be unchanged (size and root) at every non-first block, not just at the checkpoint end.
       const { block: b1, messages: m1 } = await mockBlockWithIndex(BlockNumber(1), /*index=*/ 0, 2, fork, 6, 2);
       const s1 = await ws.handleL2BlockAndMessages(b1, m1);
-      expect(s1.meta.messageTreeMeta.size).toBe(BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+      expect(s1.meta.messageTreeMeta.size).toBe(6n);
 
       for (let index = 1; index <= 2; index++) {
         const blockNumber = index + 1;
diff --git a/yarn-project/world-state/src/native/native_world_state.ts b/yarn-project/world-state/src/native/native_world_state.ts
index 3c02fb1a9380..f3ac3aa40de3 100644
--- a/yarn-project/world-state/src/native/native_world_state.ts
+++ b/yarn-project/world-state/src/native/native_world_state.ts
@@ -1,4 +1,4 @@
-import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { fromEntries, padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -264,21 +264,12 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   }
 
   public async handleL2BlockAndMessages(l2Block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull> {
-    // Any block may carry an L1-to-L2 message bundle and transition the L1-to-L2 message tree. Pre-flip the legacy
-    // synchronizer only ever attaches messages to the first block of a checkpoint (the whole padded checkpoint bundle),
-    // so first-in-checkpoint bundles are padded to NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP to match how the circuits build
-    // the tree, producing bit-identical trees. Non-first bundles are appended exactly as given (the post-flip compact
-    // append from the circuits). The "non-first blocks carry no messages" invariant of the legacy flow is now enforced
-    // by the caller (the synchronizer) rather than here, so the API accepts the new per-block shape ahead of the flip.
-    // Padding is the caller's transitional concern and moves entirely to the caller at the flip.
-    const isFirstBlock = l2Block.indexWithinCheckpoint === 0;
-
-    // We have to pad the note hashes and nullifiers within tx effects (and, for a first-in-checkpoint block, the l1 to
-    // l2 messages) because that's how the trees are built by circuits.
-    const paddedL1ToL2Messages = isFirstBlock
-      ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
-      : l1ToL2Messages;
+    // Any block may carry an L1-to-L2 message bundle and transition the L1-to-L2 message tree by its real (unpadded,
+    // compact) leaves, matching how the circuits build the tree post-flip (AZIP-22 Fast Inbox).
+    const paddedL1ToL2Messages = l1ToL2Messages;
 
+    // We have to pad the note hashes and nullifiers within tx effects because that's how the trees are built by
+    // circuits.
     const paddedNoteHashes = l2Block.body.txEffects.flatMap(txEffect =>
       padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
     );
diff --git a/yarn-project/world-state/src/synchronizer/server_world_state_synchronizer.ts b/yarn-project/world-state/src/synchronizer/server_world_state_synchronizer.ts
index 124cefd0fb4d..1d0c963bfe4a 100644
--- a/yarn-project/world-state/src/synchronizer/server_world_state_synchronizer.ts
+++ b/yarn-project/world-state/src/synchronizer/server_world_state_synchronizer.ts
@@ -1,9 +1,9 @@
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
-import { assert } from '@aztec/foundation/validation';
 import {
   type BlockHash,
   EventDrivenL2BlockStream,
@@ -369,16 +369,25 @@ export class ServerWorldStateSynchronizer
   private async handleL2Blocks(l2Blocks: L2Block[]) {
     this.log.debug(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
 
-    // Fetch the L1->L2 messages for the first block in a checkpoint.
+    // Derive each block's real L1-to-L2 message bundle from the compact leaf-index range it inserted (AZIP-22 Fast
+    // Inbox): the messages between the parent block's L1-to-L2 tree leaf count and this block's, resolved via the
+    // Inbox buckets. Blocks in a batch are consecutive, so we track the running leaf count.
     const messagesForBlocks = new Map<BlockNumber, Fr[]>();
-    await Promise.all(
-      l2Blocks
-        .filter(b => b.indexWithinCheckpoint === 0)
-        .map(async block => {
-          const l1ToL2Messages = await this.l2BlockSource.getL1ToL2Messages(block.checkpointNumber);
-          messagesForBlocks.set(block.number, l1ToL2Messages);
-        }),
-    );
+    let prevLeafCount = await this.getL1ToL2LeafCountBefore(l2Blocks[0].number);
+    for (const block of l2Blocks) {
+      const blockLeafCount = BigInt(block.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+      if (blockLeafCount > prevLeafCount) {
+        const startBucket = await this.l2BlockSource.getInboxBucketByTotalMsgCount(prevLeafCount);
+        const endBucket = await this.l2BlockSource.getInboxBucketByTotalMsgCount(blockLeafCount);
+        if (startBucket !== undefined && endBucket !== undefined) {
+          messagesForBlocks.set(
+            block.number,
+            await this.l2BlockSource.getL1ToL2MessagesBetweenBuckets(startBucket.seq, endBucket.seq),
+          );
+        }
+      }
+      prevLeafCount = blockLeafCount;
+    }
 
     let updateStatus: WorldStateStatusFull | undefined = undefined;
     for (const block of l2Blocks) {
@@ -401,6 +410,16 @@ export class ServerWorldStateSynchronizer
     this.instrumentation.updateWorldStateMetrics(updateStatus);
   }
 
+  /** The L1-to-L2 message tree leaf count as of the block before `blockNumber` (0 if that block is genesis). */
+  private async getL1ToL2LeafCountBefore(blockNumber: BlockNumber): Promise<bigint> {
+    const parentNumber = blockNumber - 1;
+    if (parentNumber < INITIAL_L2_BLOCK_NUM) {
+      return 0n;
+    }
+    const parentBlock = await this.l2BlockSource.getBlockData({ number: BlockNumber(parentNumber) });
+    return parentBlock === undefined ? 0n : BigInt(parentBlock.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+  }
+
   /**
    * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
    * @param l2Block - The L2 block to handle.
@@ -408,13 +427,6 @@ export class ServerWorldStateSynchronizer
    * @returns Whether the block handled was produced by this same node.
    */
   protected async handleL2Block(l2Block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull> {
-    // Transitional invariant (pre-flip): the legacy per-checkpoint fetch only ever attaches messages to the first
-    // block of a checkpoint, so no non-first block should carry a bundle here. World state itself now accepts a bundle
-    // on any block; this rule is owned by the synchronizer until the flip switches it to per-block message derivation.
-    assert(
-      l2Block.indexWithinCheckpoint === 0 || l1ToL2Messages.length === 0,
-      `L1 to L2 messages must be empty for non-first blocks, but got ${l1ToL2Messages.length} messages for block ${l2Block.number} (index ${l2Block.indexWithinCheckpoint} within checkpoint).`,
-    );
     this.log.debug(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
       blockNumber: l2Block.number,
       blockHash: await l2Block.hash().then(h => h.toString()),
diff --git a/yarn-project/world-state/src/test/utils.ts b/yarn-project/world-state/src/test/utils.ts
index 8657d7e6fb18..0e9b49229f89 100644
--- a/yarn-project/world-state/src/test/utils.ts
+++ b/yarn-project/world-state/src/test/utils.ts
@@ -50,13 +50,9 @@ export async function updateBlockState(block: L2Block, l1ToL2Messages: Fr[], for
     padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
   );
 
-  const l1ToL2MessagesPadded =
-    block.indexWithinCheckpoint === 0
-      ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
-      : l1ToL2Messages;
-
+  // Post-flip every block appends its real message leaves unpadded at compact indices (AZIP-22 Fast Inbox).
   const noteHashInsert = fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
-  const messageInsert = fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+  const messageInsert = fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
   await Promise.all([publicDataInsert, nullifierInsert, noteHashInsert, messageInsert]);
 
   const state = await fork.getStateReference();

From 0fd5a759f49bd0835baff0376a91b448d893bdac Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 11:32:27 -0300
Subject: [PATCH 06/22] feat(fast-inbox): drop bundle num_real_msgs and pad in
 the prover path (A-1384)

Align the node message-bundle representation and prover orchestrator with the
circuit flip (AZIP-22 Fast Inbox):

- stdlib L1ToL2MessageBundle drops numRealMsgs (single numMsgs real count);
  makeL1ToL2MessageBundle and the noir conversion follow.
- Prover orchestrator: compact (unpadded) L1-to-L2 tree insertion, checkpoint
  InboxParity in_hash hint fed zero, getPaddedL1ToL2Messages/getNumRealL1ToL2Messages
  retired.

Known follow-up (flagged in-code): the prover still assigns the whole checkpoint's
messages to its first block; post-flip a block carries at most
MAX_L1_TO_L2_MSGS_PER_BLOCK and a checkpoint drains across up to four blocks, so
the per-block message split (with per-block snapshots and compact frontier hints)
still needs the proving-path rework, verified by epoch-proving e2e on CI.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/conversion/server.ts                  |  1 -
 .../src/orchestrator/block-proving-state.ts   | 19 ++++++++-------
 .../orchestrator/checkpoint-proving-state.ts  | 19 +++++----------
 .../checkpoint-sub-tree-orchestrator.ts       |  9 ++------
 .../src/messaging/l1_to_l2_message_bundle.ts  | 23 ++++++++-----------
 yarn-project/stdlib/src/tests/factories.ts    |  8 ++-----
 6 files changed, 28 insertions(+), 51 deletions(-)

diff --git a/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts b/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts
index b9670f1900bc..f37702498807 100644
--- a/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts
+++ b/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts
@@ -836,7 +836,6 @@ function mapL1ToL2MessageBundleToNoir(bundle: L1ToL2MessageBundle) {
     // get the fixed-length `FixedLengthArray` the generated `L1ToL2MessageBundle.messages` type requires.
     messages: mapFieldArrayToNoir(bundle.messages, MAX_L1_TO_L2_MSGS_PER_BLOCK),
     num_msgs: mapNumberToNoir(bundle.numMsgs),
-    num_real_msgs: mapNumberToNoir(bundle.numRealMsgs),
   };
 }
 
diff --git a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
index 63b734cb200c..9ac66d62180b 100644
--- a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
+++ b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
@@ -12,7 +12,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { L1ToL2MessageBundle } from '@aztec/stdlib/messaging';
+import { L1ToL2MessageBundle, makeL1ToL2MessageBundle } from '@aztec/stdlib/messaging';
 import type { RollupHonkProofData } from '@aztec/stdlib/proofs';
 import {
   BlockRollupPublicInputs,
@@ -382,18 +382,17 @@ export class BlockProvingState {
   }
 
   /**
-   * The message bundle this block appends. Transitionally the first block carries the whole checkpoint's messages
-   * padded to `MAX_L1_TO_L2_MSGS_PER_BLOCK` — inserted as a full aligned subtree into the L1-to-L2 tree (`numMsgs` =
-   * the cap), while only the real messages are absorbed into the message sponge (`numRealMsgs`, matching the
-   * checkpoint's InboxParity proof). Non-first blocks carry an empty bundle.
+   * The real-count message bundle this block appends (AZIP-22 Fast Inbox): the real leaves inserted at compact indices
+   * and absorbed into the message sponge.
+   *
+   * TODO(fast-inbox): the prover still assigns the whole checkpoint's messages to the first block. Post-flip a block
+   * carries at most `MAX_L1_TO_L2_MSGS_PER_BLOCK` and a checkpoint drains its consumption across up to four blocks, so
+   * this must split the checkpoint's messages per block (with per-block start/end snapshots and full-height frontier
+   * hints at compact indices). Requires the proving-path rework; verified by epoch-proving e2e on CI.
    */
   #getMessageBundle(): L1ToL2MessageBundle {
     if (this.isFirstBlock) {
-      return new L1ToL2MessageBundle(
-        this.parentCheckpoint.getPaddedL1ToL2Messages(),
-        MAX_L1_TO_L2_MSGS_PER_BLOCK,
-        this.parentCheckpoint.getNumRealL1ToL2Messages(),
-      );
+      return makeL1ToL2MessageBundle(this.parentCheckpoint.getL1ToL2Messages());
     }
     return L1ToL2MessageBundle.empty();
   }
diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
index 9af153046a78..a5eabf11a6df 100644
--- a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
+++ b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
@@ -10,7 +10,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { L1ToL2MessageSponge, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import { L1ToL2MessageSponge } from '@aztec/stdlib/messaging';
 import { InboxParityPrivateInputs, type ParityPublicInputs } from '@aztec/stdlib/parity';
 import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
@@ -54,9 +54,6 @@ export class CheckpointProvingState {
       Fr,
       typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH
     >,
-    // The checkpoint's messages padded to `MAX_L1_TO_L2_MSGS_PER_CHECKPOINT` (the first block's transitional bundle,
-    // inserted as a full subtree into the L1-to-L2 tree).
-    private readonly paddedL1ToL2Messages: Fr[],
     // Message-bundle sponge over the checkpoint's real messages (real-count absorb). Equals the InboxParity proof's
     // end sponge and the sponge the block roots accumulate, so it is threaded into non-first block roots as their
     // inherited `startMsgSponge`.
@@ -71,14 +68,9 @@ export class CheckpointProvingState {
     this.firstBlockNumber = BlockNumber(headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1);
   }
 
-  /** The checkpoint's messages padded to the per-checkpoint cap (the first block's transitional bundle). */
-  public getPaddedL1ToL2Messages(): Fr[] {
-    return this.paddedL1ToL2Messages;
-  }
-
-  /** Number of real (non-padding) L1-to-L2 messages in the checkpoint — the sponge/InboxParity real-count. */
-  public getNumRealL1ToL2Messages(): number {
-    return this.l1ToL2Messages.length;
+  /** The checkpoint's real L1-to-L2 messages (unpadded), consumed across its blocks (AZIP-22 Fast Inbox). */
+  public getL1ToL2Messages(): Fr[] {
+    return this.l1ToL2Messages;
   }
 
   /** The message-bundle sponge over the checkpoint's real messages (real-count absorb) — inherited by non-first block roots. */
@@ -179,7 +171,8 @@ export class CheckpointProvingState {
       this.l1ToL2Messages,
       this.startInboxRollingHash,
       L1ToL2MessageSponge.empty(),
-      computeInHashFromL1ToL2Messages(this.l1ToL2Messages),
+      // Legacy in_hash is dead post-flip; the InboxParity pass-through hint carries zero (AZIP-22 Fast Inbox).
+      Fr.ZERO,
       this.constants.vkTreeRoot,
       this.constants.proverId,
     );
diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
index ad155053c2a9..036cd6340251 100644
--- a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
+++ b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
@@ -3,11 +3,9 @@ import {
   type ARCHIVE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
-  MAX_L1_TO_L2_MSGS_PER_CHECKPOINT,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
 import { BlockNumber, type EpochNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { AbortError } from '@aztec/foundation/error';
 import type { LoggerBindings } from '@aztec/foundation/log';
@@ -524,10 +522,8 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       newL1ToL2MessageSubtreeRootSiblingPath,
     } = await this.updateL1ToL2MessageTree(l1ToL2Messages, db);
 
-    // The first block inserts the whole checkpoint's messages as a full padded subtree into the L1-to-L2 tree, so keep
-    // the padded array for the block-root bundle. The message sponge, however, absorbs only the real messages
-    // (real-count), so it matches the checkpoint's single InboxParity proof; non-first block roots inherit this sponge.
-    const paddedL1ToL2Messages = padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT);
+    // The message sponge absorbs the checkpoint's real messages (real-count), matching the checkpoint's single
+    // InboxParity proof; non-first block roots inherit this sponge (AZIP-22 Fast Inbox).
     const checkpointMsgSponge = L1ToL2MessageSponge.empty();
     await checkpointMsgSponge.absorb(l1ToL2Messages);
 
@@ -543,7 +539,6 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       lastL1ToL2MessageSubtreeRootSiblingPath,
       newL1ToL2MessageTreeSnapshot,
       newL1ToL2MessageSubtreeRootSiblingPath,
-      paddedL1ToL2Messages,
       checkpointMsgSponge,
       Number(this.epochNumber),
       /* isAlive */ () => !this.cancelled,
diff --git a/yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts b/yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts
index a35c4c1c9e7c..2034ab3fdb70 100644
--- a/yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts
+++ b/yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts
@@ -6,20 +6,17 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 /**
- * A block's L1-to-L2 message bundle: the leaves it inserts into the L1-to-L2 message tree plus the two counts a block
- * root needs — one for the (transitionally padded) tree insert, one for the real-count sponge absorb. See the Noir
- * `L1ToL2MessageBundle`. Once the tree insert becomes real-count too, `numMsgs === numRealMsgs` and `numRealMsgs` is
- * dropped.
+ * A block's L1-to-L2 message bundle: the real message leaves it inserts into the L1-to-L2 message tree and the count
+ * that drives both the compact (unpadded) tree append and the message-sponge absorb (AZIP-22 Fast Inbox). See the Noir
+ * `L1ToL2MessageBundle`.
  */
 export class L1ToL2MessageBundle {
   constructor(
-    /** The message leaves, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a plain array (not a tuple)
-     * to avoid TS's deep-instantiation limit on the 1024-lane type. */
+    /** The real message leaves in the leading lanes, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a
+     * plain array (not a tuple) to avoid TS's deep-instantiation limit on the wide type. */
     public readonly messages: Fr[],
-    /** Number of leaves inserted into the L1-to-L2 message tree (the padded subtree size, or 0 for an empty block). */
+    /** Number of real messages: drives both the compact tree append and the sponge absorb. */
     public readonly numMsgs: number,
-    /** Number of real (non-padding) messages absorbed into the message sponge. */
-    public readonly numRealMsgs: number,
   ) {}
 
   /** An empty bundle: no leaves inserted, nothing absorbed. */
@@ -27,12 +24,11 @@ export class L1ToL2MessageBundle {
     return new L1ToL2MessageBundle(
       Array.from({ length: MAX_L1_TO_L2_MSGS_PER_BLOCK }, () => Fr.ZERO),
       0,
-      0,
     );
   }
 
   toBuffer() {
-    return serializeToBuffer(this.messages, this.numMsgs, this.numRealMsgs);
+    return serializeToBuffer(this.messages, this.numMsgs);
   }
 
   toString() {
@@ -43,7 +39,7 @@ export class L1ToL2MessageBundle {
     const reader = BufferReader.asReader(buffer);
     // Array.from (not readArray with the literal cap) keeps the type `Fr[]` and avoids TS's deep-tuple instantiation.
     const messages = Array.from({ length: MAX_L1_TO_L2_MSGS_PER_BLOCK }, () => Fr.fromBuffer(reader));
-    return new L1ToL2MessageBundle(messages, reader.readNumber(), reader.readNumber());
+    return new L1ToL2MessageBundle(messages, reader.readNumber());
   }
 
   static fromString(str: string) {
@@ -59,12 +55,11 @@ export class L1ToL2MessageBundle {
   }
 }
 
-/** Pads `messages` to a full subtree and wraps it into a bundle whose tree-insert count is the padded subtree size. */
+/** Wraps `messages` (the real leaves) into a bundle: the leaves fill the leading lanes, the count is the real count. */
 export function makeL1ToL2MessageBundle(messages: Fr[]): L1ToL2MessageBundle {
   // Explicit `<Fr, number>` keeps the result `Fr[]`; padding to the literal cap would otherwise infer a deep tuple.
   return new L1ToL2MessageBundle(
     padArrayEnd<Fr, number>(messages, Fr.ZERO, MAX_L1_TO_L2_MSGS_PER_BLOCK),
-    MAX_L1_TO_L2_MSGS_PER_BLOCK,
     messages.length,
   );
 }
diff --git a/yarn-project/stdlib/src/tests/factories.ts b/yarn-project/stdlib/src/tests/factories.ts
index 58374d0ae2d5..06f5fcdd5e00 100644
--- a/yarn-project/stdlib/src/tests/factories.ts
+++ b/yarn-project/stdlib/src/tests/factories.ts
@@ -966,11 +966,7 @@ export function makeTxMergeRollupPrivateInputs(seed = 0): TxMergeRollupPrivateIn
 export function makeBlockRootFirstRollupPrivateInputs(seed = 0) {
   return new BlockRootFirstRollupPrivateInputs(
     [makeProofData(seed + 0x1000, makeTxRollupPublicInputs), makeProofData(seed + 0x2000, makeTxRollupPublicInputs)],
-    new L1ToL2MessageBundle(
-      makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500),
-      MAX_L1_TO_L2_MSGS_PER_BLOCK,
-      MAX_L1_TO_L2_MSGS_PER_BLOCK,
-    ),
+    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), MAX_L1_TO_L2_MSGS_PER_BLOCK),
     makeAppendOnlyTreeSnapshot(seed + 0x3000),
     makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_TREE_HEIGHT),
     makeSiblingPath(seed + 0x5000, ARCHIVE_HEIGHT),
@@ -980,7 +976,7 @@ export function makeBlockRootFirstRollupPrivateInputs(seed = 0) {
 export function makeBlockRootSingleTxRollupPrivateInputs(seed = 0) {
   return new BlockRootSingleTxRollupPrivateInputs(
     makeProofData(seed + 0x1000, makeTxRollupPublicInputs),
-    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), 0, 0),
+    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), 0),
     makeAppendOnlyTreeSnapshot(seed + 0x2800),
     makeL1ToL2MessageSponge(seed + 0x3000),
     makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_TREE_HEIGHT),

From 6004cf3207fc6e479547998e36eea9be8437a05d Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 11:36:13 -0300
Subject: [PATCH 07/22] feat(fast-inbox): drop archiver inHash cross-check and
 TXE message padding (A-1384)

- Archiver l1_synchronizer stops cross-checking the (now-zero) checkpoint inHash;
  the consensus Inbox rolling hash is verified on L1 at propose (AZIP-22 Fast Inbox).
- TXE appends real message leaves unpadded at compact indices (synchronizer,
  block_creation) and stops padding empty blocks to a full subtree.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../archiver/src/modules/l1_synchronizer.ts   | 22 ++-----------------
 .../oracle/txe_oracle_top_level_context.ts    | 12 +++-------
 .../txe/src/state_machine/synchronizer.ts     | 12 ++--------
 yarn-project/txe/src/utils/block_creation.ts  | 13 +++--------
 4 files changed, 10 insertions(+), 49 deletions(-)

diff --git a/yarn-project/archiver/src/modules/l1_synchronizer.ts b/yarn-project/archiver/src/modules/l1_synchronizer.ts
index 1739dffccde2..57bbcedf2672 100644
--- a/yarn-project/archiver/src/modules/l1_synchronizer.ts
+++ b/yarn-project/archiver/src/modules/l1_synchronizer.ts
@@ -30,7 +30,6 @@ import {
   PublishedCheckpoint,
 } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, getEpochAtSlot, getSlotAtNextL1Block } from '@aztec/stdlib/epoch-helpers';
-import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import type { CoordinationSignatureContext } from '@aztec/stdlib/p2p';
 import { type Traceable, type Tracer, execInSpan, trackSpan } from '@aztec/telemetry-client';
 
@@ -1013,25 +1012,8 @@ export class ArchiverL1Synchronizer implements Traceable {
       for (const calldataCheckpoint of checkpointsToIngest) {
         const published = publishedByNumber.get(calldataCheckpoint.checkpointNumber)!;
 
-        // Check the inHash of the checkpoint against the l1->l2 messages.
-        // The messages should've been synced up to the currentL1BlockNumber and must be available for the published
-        // checkpoints we just retrieved.
-        const l1ToL2Messages = await this.stores.messages.getL1ToL2Messages(published.checkpoint.number);
-        const computedInHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
-        const publishedInHash = published.checkpoint.header.inHash;
-        if (!computedInHash.equals(publishedInHash)) {
-          this.log.fatal(`Mismatch inHash for checkpoint ${published.checkpoint.number}`, {
-            checkpointHash: published.checkpoint.hash(),
-            l1BlockNumber: published.l1.blockNumber,
-            computedInHash,
-            publishedInHash,
-          });
-          // Throwing an error since this is most likely caused by a bug.
-          throw new Error(
-            `Mismatch inHash for checkpoint ${published.checkpoint.number}. Expected ${computedInHash} but got ${publishedInHash}`,
-          );
-        }
-
+        // The legacy inHash cross-check is dead post-flip (the header carries zero): the consensus Inbox rolling hash
+        // is verified on L1 at propose, so no equivalent check is needed here (AZIP-22 Fast Inbox).
         validCheckpoints.push(published);
         this.log.debug(
           `Ingesting new checkpoint ${published.checkpoint.number} with ${published.checkpoint.blocks.length} blocks`,
diff --git a/yarn-project/txe/src/oracle/txe_oracle_top_level_context.ts b/yarn-project/txe/src/oracle/txe_oracle_top_level_context.ts
index de494d8618a0..b39363a52573 100644
--- a/yarn-project/txe/src/oracle/txe_oracle_top_level_context.ts
+++ b/yarn-project/txe/src/oracle/txe_oracle_top_level_context.ts
@@ -1,8 +1,4 @@
-import {
-  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-  MAX_PRIVATE_LOGS_PER_TX,
-  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-} from '@aztec/constants';
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Schnorr } from '@aztec/foundation/crypto/schnorr';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -658,8 +654,7 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
 
     txEffect.txHash = new TxHash(new Fr(blockNumber));
 
-    const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-    await forkedWorldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+    // Post-flip TXE blocks carry no L1-to-L2 messages, so the message tree is left unadvanced (AZIP-22 Fast Inbox).
 
     const l2Block = await makeTXEBlock(forkedWorldTrees, globals, [txEffect]);
 
@@ -823,8 +818,7 @@ export class TXEOracleTopLevelContext implements IMiscOracle, ITxeExecutionOracl
 
     txEffect.txHash = new TxHash(new Fr(blockNumber));
 
-    const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
-    await forkedWorldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+    // Post-flip TXE blocks carry no L1-to-L2 messages, so the message tree is left unadvanced (AZIP-22 Fast Inbox).
 
     const l2Block = await makeTXEBlock(forkedWorldTrees, globals, [txEffect]);
 
diff --git a/yarn-project/txe/src/state_machine/synchronizer.ts b/yarn-project/txe/src/state_machine/synchronizer.ts
index ec1d32c1da6a..6f61646ffba1 100644
--- a/yarn-project/txe/src/state_machine/synchronizer.ts
+++ b/yarn-project/txe/src/state_machine/synchronizer.ts
@@ -1,6 +1,4 @@
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { AvmSimulatorPool } from '@aztec/simulator/server';
 import type { BlockHash, L2Block } from '@aztec/stdlib/block';
@@ -35,14 +33,8 @@ export class TXESynchronizer implements WorldStateSynchronizer {
   }
 
   public async handleL2Block(block: L2Block, l1ToL2Messages: Fr[] = []) {
-    // Pad the bundle only for a first-in-checkpoint block, matching how the circuits (and native world state) build the
-    // message tree. TXE mines one block per checkpoint, so this is always the first block, but keep the condition
-    // explicit so the caller matches the per-block message-insertion semantics of handleL2BlockAndMessages.
-    const messages =
-      block.indexWithinCheckpoint === 0
-        ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
-        : l1ToL2Messages;
-    await this.nativeWorldStateService.handleL2BlockAndMessages(block, messages);
+    // Append the block's real message leaves unpadded at compact indices (AZIP-22 Fast Inbox).
+    await this.nativeWorldStateService.handleL2BlockAndMessages(block, l1ToL2Messages);
 
     this.blockNumber = block.header.globalVariables.blockNumber;
   }
diff --git a/yarn-project/txe/src/utils/block_creation.ts b/yarn-project/txe/src/utils/block_creation.ts
index dce7c90e1216..2354c0530558 100644
--- a/yarn-project/txe/src/utils/block_creation.ts
+++ b/yarn-project/txe/src/utils/block_creation.ts
@@ -1,9 +1,4 @@
-import {
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  NULLIFIER_SUBTREE_HEIGHT,
-  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-} from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -36,10 +31,8 @@ export async function insertTxEffectIntoWorldTrees(
     NULLIFIER_SUBTREE_HEIGHT,
   );
 
-  await worldTrees.appendLeaves(
-    MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-    padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
-  );
+  // Append the block's real message leaves unpadded at compact indices (AZIP-22 Fast Inbox).
+  await worldTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
 
   // We do not need to add public data writes because we apply them as we go.
 }

From 29383b8fb26426cb08038d2f34f13c77fb54911b Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 12:09:34 -0300
Subject: [PATCH 08/22] feat(fast-inbox): split checkpoint messages per block
 in the prover (A-1384)

Prove streaming per-block message insertion (AZIP-22 Fast Inbox): each block root
now appends its own real message slice at compact indices instead of the whole
checkpoint being padded into the first block.

- checkpoint-prover: slices the checkpoint's messages per block from the blocks'
  L1-to-L2 leaf-count ranges and feeds each block its slice.
- CheckpointSubTreeOrchestrator.startNewBlock: inserts the block's slice, capturing
  the per-block start/end snapshots and a full-height frontier at the compact start
  index (new getFrontierSiblingPath helper); startCheckpoint no longer inserts
  messages up front.
- BlockProvingState/CheckpointProvingState carry per-block snapshots + the block's
  own slice; getPaddedL1ToL2Messages/getNumRealL1ToL2Messages retired.

Prover orchestrator unit suites verify on CI (bb proving is not local); test mocks
updated for compact per-block insertion.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../prover-client/src/mocks/test_context.ts   | 11 ++--
 .../orchestrator/block-building-helpers.ts    |  9 +++
 .../src/orchestrator/block-proving-state.ts   | 49 ++++++---------
 .../orchestrator/checkpoint-proving-state.ts  | 35 ++++-------
 .../checkpoint-sub-tree-orchestrator.test.ts  | 16 ++---
 .../checkpoint-sub-tree-orchestrator.ts       | 62 ++++++-------------
 .../top-tree-orchestrator.test.ts             |  9 ++-
 .../src/test/bb_prover_full_rollup.test.ts    |  2 +-
 .../regenerate_rollup_sample_inputs.test.ts   |  2 +-
 .../prover-node/src/job/checkpoint-prover.ts  | 38 ++++++------
 10 files changed, 99 insertions(+), 134 deletions(-)

diff --git a/yarn-project/prover-client/src/mocks/test_context.ts b/yarn-project/prover-client/src/mocks/test_context.ts
index 657a4cf97268..d0d8e067d3bd 100644
--- a/yarn-project/prover-client/src/mocks/test_context.ts
+++ b/yarn-project/prover-client/src/mocks/test_context.ts
@@ -1,8 +1,7 @@
 import type { BBProverConfig } from '@aztec/bb-prover';
 import { TestCircuitProver } from '@aztec/bb-prover';
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd, times, timesAsync } from '@aztec/foundation/collection';
+import { times, timesAsync } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
@@ -194,12 +193,10 @@ export class TestContext {
 
     const fork = await this.worldState.fork();
 
-    // Build l1 to l2 messages.
+    // Build l1 to l2 messages. Appended unpadded at compact indices (AZIP-22 Fast Inbox); the mock assigns them all to
+    // the checkpoint's first block, matching how the per-block driver slices them.
     const l1ToL2Messages = times(numL1ToL2Messages, i => new Fr(slotNumber * 100 + i));
-    await fork.appendLeaves(
-      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-      padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
-    );
+    await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
     const newL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, fork);
 
     const startBlockNumber = this.nextBlockNumber;
diff --git a/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts b/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
index a49990f9c877..08b347be56d6 100644
--- a/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
+++ b/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
@@ -400,6 +400,15 @@ export async function getSubtreeSiblingPath(
   return fullSiblingPath.getSubtreeSiblingPath(subtreeHeight).toFields();
 }
 
+/**
+ * Returns the full-height frontier (left-sibling path) at a tree's next-available leaf index — the hint the append
+ * circuits re-hash against the snapshot root when appending leaves at a compact (unaligned) index (AZIP-22 Fast Inbox).
+ */
+export async function getFrontierSiblingPath(treeId: MerkleTreeId, db: MerkleTreeReadOperations): Promise<Fr[]> {
+  const nextAvailableLeafIndex = await db.getTreeInfo(treeId).then(t => t.size);
+  return (await db.getSiblingPath(treeId, nextAvailableLeafIndex)).toFields();
+}
+
 // Scan a tree searching for a specific value and return a membership witness proof for it
 export async function getMembershipWitnessFor<N extends number>(
   value: Fr,
diff --git a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
index 9ac66d62180b..12556925bf51 100644
--- a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
+++ b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
@@ -1,10 +1,7 @@
 import { type BlockBlobData, type BlockEndBlobData, type SpongeBlob, encodeBlockEndBlobData } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
-  L1_TO_L2_MSG_SUBTREE_HEIGHT,
-  type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   type L1_TO_L2_MSG_TREE_HEIGHT,
-  MAX_L1_TO_L2_MSGS_PER_BLOCK,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
@@ -77,12 +74,14 @@ export class BlockProvingState {
     private readonly timestamp: UInt64,
     public readonly lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
     private readonly lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
-    private readonly lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
-    private readonly lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<
-      Fr,
-      typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH
-    >,
+    // This block's L1-to-L2 message tree snapshot before and after its own bundle (AZIP-22 Fast Inbox). The start is
+    // the previous block's end (block-merge continuity); the end is this block's own post-bundle snapshot.
+    private readonly startL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
     public readonly newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
+    // Full-height frontier (left-sibling path) at the block's start index, pinning the append at a compact index.
+    private readonly l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>,
+    // This block's own real L1-to-L2 message leaves (unpadded slice).
+    private readonly l1ToL2Messages: Fr[],
     private readonly headerOfLastBlockInPreviousCheckpoint: BlockHeader,
     private readonly startSpongeBlob: SpongeBlob,
     public parentCheckpoint: CheckpointProvingState,
@@ -315,7 +314,7 @@ export class BlockProvingState {
         inputs: new BlockRootSingleTxRollupPrivateInputs(
           leftRollup,
           messageBundle,
-          this.lastL1ToL2MessageTreeSnapshot,
+          this.startL1ToL2MessageTreeSnapshot,
           startMsgSponge,
           frontierHint,
           this.lastArchiveSiblingPath,
@@ -327,7 +326,7 @@ export class BlockProvingState {
         inputs: new BlockRootRollupPrivateInputs(
           [leftRollup, rightRollup],
           messageBundle,
-          this.lastL1ToL2MessageTreeSnapshot,
+          this.startL1ToL2MessageTreeSnapshot,
           startMsgSponge,
           frontierHint,
           this.lastArchiveSiblingPath,
@@ -362,7 +361,7 @@ export class BlockProvingState {
         inputs: new BlockRootSingleTxFirstRollupPrivateInputs(
           leftRollup,
           messageBundle,
-          this.lastL1ToL2MessageTreeSnapshot,
+          this.startL1ToL2MessageTreeSnapshot,
           frontierHint,
           this.lastArchiveSiblingPath,
         ),
@@ -373,7 +372,7 @@ export class BlockProvingState {
         inputs: new BlockRootFirstRollupPrivateInputs(
           [leftRollup, rightRollup],
           messageBundle,
-          this.lastL1ToL2MessageTreeSnapshot,
+          this.startL1ToL2MessageTreeSnapshot,
           frontierHint,
           this.lastArchiveSiblingPath,
         ),
@@ -382,31 +381,21 @@ export class BlockProvingState {
   }
 
   /**
-   * The real-count message bundle this block appends (AZIP-22 Fast Inbox): the real leaves inserted at compact indices
-   * and absorbed into the message sponge.
-   *
-   * TODO(fast-inbox): the prover still assigns the whole checkpoint's messages to the first block. Post-flip a block
-   * carries at most `MAX_L1_TO_L2_MSGS_PER_BLOCK` and a checkpoint drains its consumption across up to four blocks, so
-   * this must split the checkpoint's messages per block (with per-block start/end snapshots and full-height frontier
-   * hints at compact indices). Requires the proving-path rework; verified by epoch-proving e2e on CI.
+   * The real-count message bundle this block appends (AZIP-22 Fast Inbox): the block's own message slice, inserted at
+   * compact indices and absorbed into its block-root message sponge.
    */
   #getMessageBundle(): L1ToL2MessageBundle {
-    if (this.isFirstBlock) {
-      return makeL1ToL2MessageBundle(this.parentCheckpoint.getL1ToL2Messages());
-    }
-    return L1ToL2MessageBundle.empty();
+    return this.l1ToL2Messages.length === 0
+      ? L1ToL2MessageBundle.empty()
+      : makeL1ToL2MessageBundle(this.l1ToL2Messages);
   }
 
   /**
-   * Full-height frontier hint for the bundle append. The l1-to-l2 tree index is always subtree-aligned in the
-   * transitional wiring, so the bottom `L1_TO_L2_MSG_SUBTREE_HEIGHT` levels are left-child (unread, zero) and the top
-   * levels are exactly the subtree-root sibling path already captured for this block.
+   * Full-height frontier hint for the bundle append: the left-sibling path at the block's compact start index, which
+   * the block-root circuit re-hashes against its start snapshot root (AZIP-22 Fast Inbox).
    */
   #getFrontierHint(): Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT> {
-    return [
-      ...Array.from({ length: L1_TO_L2_MSG_SUBTREE_HEIGHT }, () => Fr.ZERO),
-      ...this.lastL1ToL2MessageSubtreeRootSiblingPath,
-    ] as Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>;
+    return this.l1ToL2MessageFrontierHint;
   }
 
   // Returns a specific transaction proving state
diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
index a5eabf11a6df..8ee56863cd69 100644
--- a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
+++ b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
@@ -1,7 +1,7 @@
 import { SpongeBlob } from '@aztec/blob-lib';
 import type {
   ARCHIVE_HEIGHT,
-  L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  L1_TO_L2_MSG_TREE_HEIGHT,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
@@ -42,18 +42,6 @@ export class CheckpointProvingState {
     // Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end value; genesis is zero).
     // Threaded into the InboxParity circuit so the resulting checkpoint header rolling hash matches the proposer's.
     private readonly startInboxRollingHash: Fr,
-    // The snapshot and sibling path before the new l1 to l2 message subtree is inserted.
-    private readonly lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
-    private readonly lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<
-      Fr,
-      typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH
-    >,
-    // The snapshot and sibling path after the new l1 to l2 message subtree is inserted.
-    private readonly newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
-    private readonly newL1ToL2MessageSubtreeRootSiblingPath: Tuple<
-      Fr,
-      typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH
-    >,
     // Message-bundle sponge over the checkpoint's real messages (real-count absorb). Equals the InboxParity proof's
     // end sponge and the sponge the block roots accumulate, so it is threaded into non-first block roots as their
     // inherited `startMsgSponge`.
@@ -84,20 +72,18 @@ export class CheckpointProvingState {
     totalNumTxs: number,
     lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
     lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    // Per-block L1-to-L2 message state (AZIP-22 Fast Inbox): the block's start snapshot (its parent's end), its own
+    // post-bundle end snapshot, the full-height frontier at the start index, and its own real message slice.
+    startL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
+    endL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
+    l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>,
+    l1ToL2Messages: Fr[],
   ): BlockProvingState {
     const index = Number(blockNumber) - Number(this.firstBlockNumber);
     if (index >= this.totalNumBlocks) {
       throw new Error(`Unable to start a new block at index ${index}. Expected at most ${this.totalNumBlocks} blocks.`);
     }
 
-    // If this is the first block, we use the snapshot and sibling path before the new l1 to l2 messages are inserted.
-    // Otherwise, we use the snapshot and sibling path after the new l1 to l2 messages are inserted, which will always
-    // happen in the first block.
-    const lastL1ToL2MessageTreeSnapshot =
-      index === 0 ? this.lastL1ToL2MessageTreeSnapshot : this.newL1ToL2MessageTreeSnapshot;
-    const lastL1ToL2MessageSubtreeRootSiblingPath =
-      index === 0 ? this.lastL1ToL2MessageSubtreeRootSiblingPath : this.newL1ToL2MessageSubtreeRootSiblingPath;
-
     const startSpongeBlob = index === 0 ? SpongeBlob.init() : this.blocks[index - 1]?.getEndSpongeBlob();
     if (!startSpongeBlob) {
       throw new Error(
@@ -113,9 +99,10 @@ export class CheckpointProvingState {
       timestamp,
       lastArchiveTreeSnapshot,
       lastArchiveSiblingPath,
-      lastL1ToL2MessageTreeSnapshot,
-      lastL1ToL2MessageSubtreeRootSiblingPath,
-      this.newL1ToL2MessageTreeSnapshot,
+      startL1ToL2MessageTreeSnapshot,
+      endL1ToL2MessageTreeSnapshot,
+      l1ToL2MessageFrontierHint,
+      l1ToL2Messages,
       this.headerOfLastBlockInPreviousCheckpoint,
       startSpongeBlob,
       this,
diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts
index 41ada4e52c7b..f72349b9525b 100644
--- a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts
+++ b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts
@@ -58,9 +58,9 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => {
     try {
       const resultPromise = subTree.getSubTreeResult();
 
-      for (const block of blocks) {
+      for (const [blockIndex, block] of blocks.entries()) {
         const { blockNumber, timestamp } = block.header.globalVariables;
-        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length);
+        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length, blockIndex === 0 ? l1ToL2Messages : []);
         if (block.txs.length > 0) {
           await subTree.addTxs(block.txs);
         }
@@ -104,9 +104,9 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => {
     try {
       const resultPromise = subTree.getSubTreeResult();
 
-      for (const block of blocks) {
+      for (const [blockIndex, block] of blocks.entries()) {
         const { blockNumber, timestamp } = block.header.globalVariables;
-        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length);
+        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length, blockIndex === 0 ? l1ToL2Messages : []);
         if (block.txs.length > 0) {
           await subTree.addTxs(block.txs);
         }
@@ -149,9 +149,9 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => {
     try {
       const resultPromise = subTree.getSubTreeResult();
 
-      for (const block of blocks) {
+      for (const [blockIndex, block] of blocks.entries()) {
         const { blockNumber, timestamp } = block.header.globalVariables;
-        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length);
+        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length, blockIndex === 0 ? l1ToL2Messages : []);
         if (block.txs.length > 0) {
           await subTree.addTxs(block.txs);
         }
@@ -197,9 +197,9 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => {
     try {
       const resultPromise = subTree.getSubTreeResult();
 
-      for (const block of blocks) {
+      for (const [blockIndex, block] of blocks.entries()) {
         const { blockNumber, timestamp } = block.header.globalVariables;
-        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length);
+        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length, blockIndex === 0 ? l1ToL2Messages : []);
         if (block.txs.length > 0) {
           await subTree.addTxs(block.txs);
         }
diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
index 036cd6340251..dabe0bf452b1 100644
--- a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
+++ b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
@@ -1,8 +1,7 @@
 import type { SpongeBlob } from '@aztec/blob-lib/types';
 import {
   type ARCHIVE_HEIGHT,
-  L1_TO_L2_MSG_SUBTREE_HEIGHT,
-  L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  L1_TO_L2_MSG_TREE_HEIGHT,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
 import { BlockNumber, type EpochNumber } from '@aztec/foundation/branded-types';
@@ -47,10 +46,10 @@ import { inspect } from 'util';
 
 import {
   buildHeaderFromCircuitOutputs,
+  getFrontierSiblingPath,
   getLastSiblingPath,
   getPublicChonkVerifierPrivateInputsFromTx,
   getRootTreeSiblingPath,
-  getSubtreeSiblingPath,
   getTreeSnapshot,
   insertSideEffectsAndBuildBaseRollupHints,
   validatePartialState,
@@ -260,7 +259,7 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
   @trackSpan('CheckpointSubTreeOrchestrator.startNewBlock', blockNumber => ({
     [Attributes.BLOCK_NUMBER]: blockNumber,
   }))
-  public async startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number) {
+  public async startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number, l1ToL2Messages: Fr[]) {
     if (!this.provingState) {
       throw new Error('Empty proving state. The checkpoint sub-tree has not been started.');
     }
@@ -284,12 +283,26 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
     const lastArchiveTreeSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const lastArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
 
+    // Streaming Inbox (AZIP-22 Fast Inbox): insert this block's own real message slice at compact indices, capturing
+    // the start snapshot + full-height frontier before the append and the block's own post-bundle end snapshot after.
+    const startL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+    const l1ToL2FrontierHint = assertLength(
+      await getFrontierSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db),
+      L1_TO_L2_MSG_TREE_HEIGHT,
+    );
+    await appendL1ToL2MessagesToTree(db, l1ToL2Messages);
+    const endL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+
     const blockProvingState = this.provingState.startNewBlock(
       blockNumber,
       timestamp,
       totalNumTxs,
       lastArchiveTreeSnapshot,
       lastArchiveSiblingPath,
+      startL1ToL2Snapshot,
+      endL1ToL2Snapshot,
+      l1ToL2FrontierHint,
+      l1ToL2Messages,
     );
 
     // Because `addTxs` won't be called for a block without txs, and that's where the sponge blob state is computed,
@@ -514,16 +527,9 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
     // Get archive sibling path before any block in this checkpoint lands.
     const lastArchiveSiblingPath = await getLastSiblingPath(MerkleTreeId.ARCHIVE, db);
 
-    // Insert all the l1 to l2 messages into the db. Get the states before and after the insertion.
-    const {
-      lastL1ToL2MessageTreeSnapshot,
-      lastL1ToL2MessageSubtreeRootSiblingPath,
-      newL1ToL2MessageTreeSnapshot,
-      newL1ToL2MessageSubtreeRootSiblingPath,
-    } = await this.updateL1ToL2MessageTree(l1ToL2Messages, db);
-
-    // The message sponge absorbs the checkpoint's real messages (real-count), matching the checkpoint's single
-    // InboxParity proof; non-first block roots inherit this sponge (AZIP-22 Fast Inbox).
+    // Streaming Inbox (AZIP-22 Fast Inbox): messages are inserted per block in `startNewBlock`, not the whole
+    // checkpoint up front. The message sponge still absorbs the checkpoint's real messages (real-count), matching the
+    // checkpoint's single InboxParity proof; non-first block roots inherit this sponge.
     const checkpointMsgSponge = L1ToL2MessageSponge.empty();
     await checkpointMsgSponge.absorb(l1ToL2Messages);
 
@@ -535,10 +541,6 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       lastArchiveSiblingPath,
       l1ToL2Messages,
       startInboxRollingHash,
-      lastL1ToL2MessageTreeSnapshot,
-      lastL1ToL2MessageSubtreeRootSiblingPath,
-      newL1ToL2MessageTreeSnapshot,
-      newL1ToL2MessageSubtreeRootSiblingPath,
       checkpointMsgSponge,
       Number(this.epochNumber),
       /* isAlive */ () => !this.cancelled,
@@ -552,30 +554,6 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
 
   // ---------------- private: per-block proof orchestration ----------------
 
-  private async updateL1ToL2MessageTree(l1ToL2Messages: Fr[], db: MerkleTreeWriteOperations) {
-    const lastL1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
-    const lastL1ToL2MessageSubtreeRootSiblingPath = assertLength(
-      await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db),
-      L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
-    );
-
-    // Update the local trees to include the new l1 to l2 messages.
-    await appendL1ToL2MessagesToTree(db, l1ToL2Messages);
-
-    const newL1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
-    const newL1ToL2MessageSubtreeRootSiblingPath = assertLength(
-      await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db),
-      L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
-    );
-
-    return {
-      lastL1ToL2MessageTreeSnapshot,
-      lastL1ToL2MessageSubtreeRootSiblingPath,
-      newL1ToL2MessageTreeSnapshot,
-      newL1ToL2MessageSubtreeRootSiblingPath,
-    };
-  }
-
   // Updates the merkle trees for a transaction. The first enqueued job for a transaction.
   @trackSpan('CheckpointSubTreeOrchestrator.prepareBaseRollupInputs', tx => ({
     [Attributes.TX_HASH]: tx.hash.toString(),
diff --git a/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts b/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts
index d1174460d0e6..f05ed62096b0 100644
--- a/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts
+++ b/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts
@@ -72,9 +72,14 @@ describe('prover/orchestrator/top-tree', () => {
     );
     const resultPromise = subTree.getSubTreeResult();
 
-    for (const block of fixture.blocks) {
+    for (const [blockIndex, block] of fixture.blocks.entries()) {
       const { blockNumber, timestamp } = block.header.globalVariables;
-      await subTree.startNewBlock(blockNumber, timestamp, block.txs.length);
+      await subTree.startNewBlock(
+        blockNumber,
+        timestamp,
+        block.txs.length,
+        blockIndex === 0 ? fixture.l1ToL2Messages : [],
+      );
       if (block.txs.length > 0) {
         await subTree.addTxs(block.txs);
       }
diff --git a/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts b/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts
index bfbad4b2ff03..221d1620eab4 100644
--- a/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts
+++ b/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts
@@ -93,7 +93,7 @@ describe('prover/bb_prover/full-rollup', () => {
             const { blockNumber, timestamp } = header.globalVariables;
 
             log.info(`Starting new block #${blockNumber}`);
-            await subTree.startNewBlock(blockNumber, timestamp, txs.length);
+            await subTree.startNewBlock(blockNumber, timestamp, txs.length, i === 0 ? l1ToL2Messages : []);
             if (txs.length > 0) {
               await subTree.addTxs(txs);
             }
diff --git a/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts b/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts
index af2766e2e9bc..ee96d1889046 100644
--- a/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts
+++ b/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts
@@ -146,7 +146,7 @@ describeOrSkip('prover/regenerate-rollup-sample-inputs', () => {
             const { header, txs } = blocks[i];
             const { blockNumber, timestamp } = header.globalVariables;
 
-            await subTree.startNewBlock(blockNumber, timestamp, txs.length);
+            await subTree.startNewBlock(blockNumber, timestamp, txs.length, i === 0 ? l1ToL2Messages : []);
             if (txs.length > 0) {
               await subTree.addTxs(txs);
             }
diff --git a/yarn-project/prover-node/src/job/checkpoint-prover.ts b/yarn-project/prover-node/src/job/checkpoint-prover.ts
index a42f7ba8baea..b47e72da3d66 100644
--- a/yarn-project/prover-node/src/job/checkpoint-prover.ts
+++ b/yarn-project/prover-node/src/job/checkpoint-prover.ts
@@ -1,6 +1,5 @@
-import { type ARCHIVE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import type { ARCHIVE_HEIGHT } from '@aztec/constants';
 import { BlockNumber, type EpochNumber, type SlotNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
@@ -313,21 +312,31 @@ export class CheckpointProver {
         }
       }
 
+      // Streaming Inbox (AZIP-22 Fast Inbox): the checkpoint's messages are consumed contiguously across its blocks;
+      // each block's slice runs from its parent block's L1-to-L2 leaf count to its own (compact indices make leaf
+      // count equal cumulative message count).
+      const l1ToL2LeafCount = (block: L2Block) => Number(block.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+      const checkpointStartLeafCount = l1ToL2LeafCount(this.checkpoint.blocks.at(-1)!) - this.l1ToL2Messages.length;
+
       for (let blockIndex = 0; blockIndex < this.checkpoint.blocks.length; blockIndex++) {
         const blockTimer = new Timer();
         const block = this.checkpoint.blocks[blockIndex];
         const globalVariables = block.header.globalVariables;
         const blockTxs = this.getTxsForBlock(block, txs);
 
-        await this.subTree.startNewBlock(block.number, globalVariables.timestamp, blockTxs.length);
+        const prevLeafCount =
+          blockIndex === 0 ? checkpointStartLeafCount : l1ToL2LeafCount(this.checkpoint.blocks[blockIndex - 1]);
+        const blockMessages = this.l1ToL2Messages.slice(
+          prevLeafCount - checkpointStartLeafCount,
+          l1ToL2LeafCount(block) - checkpointStartLeafCount,
+        );
+
+        await this.subTree.startNewBlock(block.number, globalVariables.timestamp, blockTxs.length, blockMessages);
         if (signal.aborted) {
           return;
         }
 
-        const db = await this.createFork(
-          BlockNumber(block.number - 1),
-          blockIndex === 0 ? this.l1ToL2Messages : undefined,
-        );
+        const db = await this.createFork(BlockNumber(block.number - 1), blockMessages);
         try {
           if (signal.aborted) {
             return;
@@ -465,19 +474,10 @@ export class CheckpointProver {
     return processedTxs;
   }
 
-  private async createFork(blockNumber: BlockNumber, l1ToL2Messages: Fr[] | undefined) {
+  private async createFork(blockNumber: BlockNumber, l1ToL2Messages: Fr[]) {
     const db = await this.deps.dbProvider.fork(blockNumber);
-
-    if (l1ToL2Messages !== undefined) {
-      const l1ToL2MessagesPadded = padArrayEnd<Fr, number>(
-        l1ToL2Messages,
-        Fr.ZERO,
-        NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-        'Too many L1 to L2 messages',
-      );
-      await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    }
-
+    // Append the block's real message leaves unpadded at compact indices (AZIP-22 Fast Inbox).
+    await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
     return db;
   }
 }

From afd4ca892da81816fd0207672fef040cb1d57ea0 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 12:09:46 -0300
Subject: [PATCH 09/22] feat(fast-inbox): answer message-checkpoint queries
 from records, not index math (A-1384)

Post-flip, 1024-per-checkpoint index arithmetic is wrong for compact indices, so
the node answers from stored records instead (AZIP-22 Fast Inbox):

- getL1ToL2MessageCheckpoint binary-searches the block records for the first block
  whose L1-to-L2 tree leaf count exceeds the message index, returning that block's
  checkpoint (portal claim helpers depend on this).
- prover-node collectRegisterData derives the checkpoint's consumed messages from
  the Inbox buckets between the parent checkpoint's position and the last block,
  replacing the legacy per-checkpoint getL1ToL2Messages fetch.

The message_store index-formula methods (smallestIndexForCheckpoint etc.) have no
correctness-critical live callers left; the public-simulator fetch degrades safely
without them. They are retired in FI-18.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../aztec-node/src/aztec-node/server.test.ts  | 12 ++++--
 .../src/modules/node_world_state_queries.ts   | 40 +++++++++++++++++--
 yarn-project/prover-node/src/prover-node.ts   | 29 +++++++++++++-
 3 files changed, 72 insertions(+), 9 deletions(-)

diff --git a/yarn-project/aztec-node/src/aztec-node/server.test.ts b/yarn-project/aztec-node/src/aztec-node/server.test.ts
index 734c0ba01e16..ae343db4a198 100644
--- a/yarn-project/aztec-node/src/aztec-node/server.test.ts
+++ b/yarn-project/aztec-node/src/aztec-node/server.test.ts
@@ -37,7 +37,6 @@ import type { ContractDataSource, ContractInstanceWithAddress } from '@aztec/std
 import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { L2LogsSource, MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { mockTx, randomContractInstanceWithAddress } from '@aztec/stdlib/testing';
@@ -1569,13 +1568,18 @@ describe('aztec node', () => {
   });
 
   describe('getL1ToL2MessageCheckpoint', () => {
-    it('returns the checkpoint for a message at index 0n', async () => {
+    it('returns the checkpoint of the block that consumed the message', async () => {
       const msg = Fr.random();
       l1ToL2MessageSource.getL1ToL2MessageIndex.mockResolvedValue(0n);
+      // The first block (checkpoint 1) consumed message index 0: its L1-to-L2 tree leaf count is 1 > 0.
+      l2BlockSource.getBlockNumber.mockResolvedValue(BlockNumber(1));
+      l2BlockSource.getBlockData.mockResolvedValue({
+        checkpointNumber: CheckpointNumber(1),
+        header: { state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 1 } } },
+      } as unknown as BlockData);
 
       const result = await node.getL1ToL2MessageCheckpoint(msg);
-      expect(result).toEqual(InboxLeaf.checkpointNumberFromIndex(0n));
-      expect(result).not.toBeUndefined();
+      expect(result).toEqual(CheckpointNumber(1));
     });
 
     it('returns undefined when the message is not found', async () => {
diff --git a/yarn-project/aztec-node/src/modules/node_world_state_queries.ts b/yarn-project/aztec-node/src/modules/node_world_state_queries.ts
index 1e7f6dcd0a22..46d280da0403 100644
--- a/yarn-project/aztec-node/src/modules/node_world_state_queries.ts
+++ b/yarn-project/aztec-node/src/modules/node_world_state_queries.ts
@@ -1,4 +1,9 @@
-import { ARCHIVE_HEIGHT, type L1_TO_L2_MSG_TREE_HEIGHT, type NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
+import {
+  ARCHIVE_HEIGHT,
+  INITIAL_L2_BLOCK_NUM,
+  type L1_TO_L2_MSG_TREE_HEIGHT,
+  type NOTE_HASH_TREE_HEIGHT,
+} from '@aztec/constants';
 import { BlockNumber, type CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
 import { chunkBy } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -7,6 +12,7 @@ import { sleep } from '@aztec/foundation/sleep';
 import { MembershipWitness, type SiblingPath } from '@aztec/foundation/trees';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
+  type BlockData,
   type BlockHash,
   type BlockParameter,
   type DataInBlock,
@@ -16,7 +22,7 @@ import {
 } from '@aztec/stdlib/block';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { InboxLeaf, type L1ToL2MessageSource, type L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
+import type { L1ToL2MessageSource, L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
 import {
   MerkleTreeId,
   type NullifierLeafPreimage,
@@ -179,7 +185,35 @@ export class NodeWorldStateQueries {
 
   public async getL1ToL2MessageCheckpoint(l1ToL2Message: Fr): Promise<CheckpointNumber | undefined> {
     const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
-    return messageIndex !== undefined ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
+    if (messageIndex === undefined) {
+      return undefined;
+    }
+    // Post-flip, an L1-to-L2 message at compact leaf index `i` is consumed by the first block whose L1-to-L2 tree leaf
+    // count exceeds `i` (leaf counts are monotonic in block number); that block's checkpoint is the answer, sourced
+    // from the stored block records rather than 1024-per-checkpoint index arithmetic (AZIP-22 Fast Inbox).
+    const block = await this.#findBlockConsumingL1ToL2MessageIndex(messageIndex);
+    return block?.checkpointNumber;
+  }
+
+  /** Binary-searches the block records for the first block whose L1-to-L2 tree leaf count exceeds `messageIndex`. */
+  async #findBlockConsumingL1ToL2MessageIndex(messageIndex: bigint): Promise<BlockData | undefined> {
+    let lo = INITIAL_L2_BLOCK_NUM;
+    let hi = await this.blockSource.getBlockNumber();
+    let result: BlockData | undefined;
+    while (lo <= hi) {
+      const mid = lo + Math.floor((hi - lo) / 2);
+      const block = await this.blockSource.getBlockData({ number: BlockNumber(mid) });
+      if (block === undefined) {
+        break;
+      }
+      if (BigInt(block.header.state.l1ToL2MessageTree.nextAvailableLeafIndex) > messageIndex) {
+        result = block;
+        hi = mid - 1;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return result;
   }
 
   /**
diff --git a/yarn-project/prover-node/src/prover-node.ts b/yarn-project/prover-node/src/prover-node.ts
index f2eabd024530..c65f7021441f 100644
--- a/yarn-project/prover-node/src/prover-node.ts
+++ b/yarn-project/prover-node/src/prover-node.ts
@@ -13,7 +13,9 @@ import { getLastSiblingPath } from '@aztec/prover-client/helpers';
 import { ChonkCache } from '@aztec/prover-client/orchestrator';
 import { type AvmSimulator, PublicProcessorFactory } from '@aztec/simulator/server';
 import {
+  type BlockHeader,
   EventDrivenL2BlockStream,
+  type L2Block,
   type L2BlockId,
   type L2BlockSource,
   type L2BlockStreamEvent,
@@ -349,9 +351,11 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
   ): Promise<RegisterCheckpointData> {
     const previousBlockNumber = BlockNumber(checkpoint.blocks[0].number - 1);
     const previousBlockHeader = await this.gatherPreviousBlockHeader(previousBlockNumber);
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpoint.number);
-    const previousInboxRollingHash = await this.gatherPreviousInboxRollingHash(checkpoint.number);
     const lastBlock = checkpoint.blocks.at(-1)!;
+    // Streaming Inbox (AZIP-22 Fast Inbox): the checkpoint's consumed messages are those in the Inbox buckets between
+    // the parent checkpoint's consumed position and this checkpoint's last block (compact leaf-count range).
+    const l1ToL2Messages = await this.deriveCheckpointConsumedMessages(previousBlockHeader, lastBlock);
+    const previousInboxRollingHash = await this.gatherPreviousInboxRollingHash(checkpoint.number);
     const lastBlockHash = await lastBlock.header.hash();
     await this.worldState.syncImmediate(lastBlock.number, lastBlockHash);
     const previousArchiveSiblingPath = await getLastSiblingPath(
@@ -367,6 +371,27 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
     };
   }
 
+  /**
+   * Derives a checkpoint's consumed L1-to-L2 messages, in order, from the Inbox buckets between the parent
+   * checkpoint's consumed position (the block before the checkpoint's first block) and the checkpoint's last block
+   * (compact leaf counts), for the prover to slice per block (AZIP-22 Fast Inbox).
+   */
+  private async deriveCheckpointConsumedMessages(previousBlockHeader: BlockHeader, lastBlock: L2Block): Promise<Fr[]> {
+    const startLeafCount = BigInt(previousBlockHeader.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+    const endLeafCount = BigInt(lastBlock.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+    if (endLeafCount <= startLeafCount) {
+      return [];
+    }
+    const startBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(startLeafCount);
+    const endBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(endLeafCount);
+    if (startBucket === undefined || endBucket === undefined) {
+      throw new Error(
+        `Cannot resolve consumed messages for checkpoint ending at block ${lastBlock.number} from the Inbox buckets`,
+      );
+    }
+    return this.l1ToL2MessageSource.getL1ToL2MessagesBetweenBuckets(startBucket.seq, endBucket.seq);
+  }
+
   /**
    * Sources the inbox rolling hash chain-start for a checkpoint: the previous checkpoint's `inboxRollingHash`, or zero
    * for the genesis checkpoint. The prover threads this into the base parity circuits so the rebuilt checkpoint header

From a8a270523e585abbd45e5978e47f602d06d533f1 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sat, 18 Jul 2026 22:06:34 -0300
Subject: [PATCH 10/22] fix(fast-inbox): thread per-block message sponges and
 wire the msgs-only block root in the prover (A-1384)

Three flip gaps surfaced by the phase-2 review:

- The prover supplied the checkpoint-wide message sponge as every non-first
  block root's start sponge. The block merge and checkpoint root circuits
  assert per-block continuity (right.start_msg_sponge == left.end_msg_sponge,
  first block empty, merged end == InboxParity sponge), so any checkpoint
  whose non-first block carried messages was unprovable. The sponge is now
  threaded per block: each block starts from the previous block's end sponge
  and absorbs its own slice.
- A zero-tx non-first block (the message-only block shape the sequencer can
  now produce) was rejected outright by BlockProvingState and by the
  lightweight builder, and the orchestrator never selected the msgs-only
  block root circuit. Both now accept a zero-tx non-first block carrying a
  non-empty bundle, and the orchestrator routes it through
  BlockRootMsgsOnlyRollupPrivateInputs (dispatch, prover method, VK
  allowlists, and job plumbing already existed).
- SequencerPublisher.enqueueProposeCheckpoint gained a required bucketHint
  parameter but the publisher unit/integration tests and the e2e synching
  test still passed three arguments and could not typecheck. The call sites
  now pass a hint (the integration suite's consumption model is reworked for
  streaming semantics separately, on the node-cleanup branch).

Also updates comments the flip left stale: the EpochProofLib note claiming
the epoch rolling hashes are unvalidated, the flag-gated wording in the
validator slashing table and proposal-handler tests, and the lightweight
builder's padded first-block bundle note (both branches append compactly
post-flip, so the branch is gone too).
---
 .../core/libraries/rollup/EpochProofLib.sol   |  6 +--
 .../src/single-node/sync/synching.test.ts     |  1 +
 .../light/lightweight_checkpoint_builder.ts   | 22 ++++----
 .../src/orchestrator/block-proving-state.ts   | 52 ++++++++++++++++---
 .../orchestrator/checkpoint-proving-state.ts  | 34 +++++++-----
 .../checkpoint-sub-tree-orchestrator.ts       | 23 ++++----
 .../l1_publisher.integration.test.ts          | 12 +++--
 .../src/publisher/sequencer-publisher.test.ts | 11 ++++
 .../src/proposal_handler.test.ts              | 12 ++---
 .../validator-client/src/proposal_handler.ts  |  4 +-
 10 files changed, 120 insertions(+), 57 deletions(-)

diff --git a/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol b/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol
index 8c163415fc40..429e062488a1 100644
--- a/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol
+++ b/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol
@@ -232,9 +232,9 @@ library EpochProofLib {
 
       publicInputs[2] = _args.outHash;
 
-      // Inbox rolling-hash chain segment consumed across the epoch (AZIP-22 Fast Inbox). Deliberately UNVALIDATED
-      // until the Fast Inbox flip, when they get checked against per-checkpoint records written at propose; for now
-      // they are only passed through to the proof's public inputs.
+      // Inbox rolling-hash chain segment consumed across the epoch (AZIP-22 Fast Inbox). The start is validated above
+      // against the record written at propose for checkpoint _start - 1; the end is pinned transitively through the
+      // stored checkpoint header hashes (see the anchoring block in assertAcceptable).
       publicInputs[3] = _args.previousInboxRollingHash;
       publicInputs[4] = _args.endInboxRollingHash;
     }
diff --git a/yarn-project/end-to-end/src/single-node/sync/synching.test.ts b/yarn-project/end-to-end/src/single-node/sync/synching.test.ts
index 4180e23eca9f..abd182aeba3e 100644
--- a/yarn-project/end-to-end/src/single-node/sync/synching.test.ts
+++ b/yarn-project/end-to-end/src/single-node/sync/synching.test.ts
@@ -502,6 +502,7 @@ describe('single-node/sync/synching', () => {
           rollupAddress: deployL1ContractsValues.l1ContractAddresses.rollupAddress,
         }),
         Signature.empty(),
+        0n,
       );
 
       await cheatCodes.rollup.markAsProven(CheckpointNumber(provenThrough));
diff --git a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
index 8d31ec7cbcb3..446a957b001f 100644
--- a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
+++ b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
@@ -181,9 +181,10 @@ export class LightweightCheckpointBuilder {
     const timings: Record<string, number> = {};
     const isFirstBlock = this.blocks.length === 0;
 
-    // Empty blocks are only allowed as the first block in a checkpoint
-    if (!isFirstBlock && txs.length === 0) {
-      throw new Error('Cannot add empty block that is not the first block in the checkpoint.');
+    // A non-first block with no txs is only allowed when it inserts a non-empty L1-to-L2 message bundle: the
+    // message-only block shape (AZIP-22 Fast Inbox), proven by the msgs-only block root.
+    if (!isFirstBlock && txs.length === 0 && (opts.l1ToL2Messages?.length ?? 0) === 0) {
+      throw new Error('Cannot add an empty non-first block that carries no L1-to-L2 messages.');
     }
 
     if (isFirstBlock) {
@@ -208,17 +209,12 @@ export class LightweightCheckpointBuilder {
     }
 
     // Streaming Inbox (AZIP-22 Fast Inbox): insert this block's L1-to-L2 message bundle before reading the end state,
-    // so the block header's L1-to-L2 tree snapshot reflects it. First-in-checkpoint bundles are padded to
-    // NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP (matching the legacy per-checkpoint insertion and the world-state
-    // synchronizer); non-first bundles are appended compactly. The logical (unpadded) messages are accumulated only
-    // once the block is fully built (below), so a mid-build failure does not pollute the checkpoint's inHash/rolling
-    // hash; the rolling hash and inHash are recomputed over them at checkpoint completion.
+    // so the block header's L1-to-L2 tree snapshot reflects it. Bundles are appended compactly (unpadded, at the
+    // tree's current next-available index). The logical messages are accumulated only once the block is fully built
+    // (below), so a mid-build failure does not pollute the checkpoint's rolling hash; the rolling hash is recomputed
+    // over them at checkpoint completion.
     if (opts.l1ToL2Messages !== undefined) {
-      if (isFirstBlock) {
-        await appendL1ToL2MessagesToTree(this.db, opts.l1ToL2Messages);
-      } else {
-        await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, opts.l1ToL2Messages);
-      }
+      await appendL1ToL2MessagesToTree(this.db, opts.l1ToL2Messages);
     }
 
     const [msGetEndState, endState] = await elapsed(() => this.db.getStateReference());
diff --git a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
index 12556925bf51..a3b3f27c66e1 100644
--- a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
+++ b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts
@@ -1,20 +1,21 @@
 import { type BlockBlobData, type BlockEndBlobData, type SpongeBlob, encodeBlockEndBlobData } from '@aztec/blob-lib';
-import {
-  type ARCHIVE_HEIGHT,
-  type L1_TO_L2_MSG_TREE_HEIGHT,
-  type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+import type {
+  ARCHIVE_HEIGHT,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { L1ToL2MessageBundle, makeL1ToL2MessageBundle } from '@aztec/stdlib/messaging';
+import { L1ToL2MessageBundle, type L1ToL2MessageSponge, makeL1ToL2MessageBundle } from '@aztec/stdlib/messaging';
 import type { RollupHonkProofData } from '@aztec/stdlib/proofs';
 import {
   BlockRollupPublicInputs,
   BlockRootEmptyTxFirstRollupPrivateInputs,
   BlockRootFirstRollupPrivateInputs,
+  BlockRootMsgsOnlyRollupPrivateInputs,
   BlockRootRollupPrivateInputs,
   BlockRootSingleTxFirstRollupPrivateInputs,
   BlockRootSingleTxRollupPrivateInputs,
@@ -44,6 +45,7 @@ export type BlockRootRollupTypeAndInputs =
   | { rollupType: 'rollup-block-root-first'; inputs: BlockRootFirstRollupPrivateInputs }
   | { rollupType: 'rollup-block-root-first-single-tx'; inputs: BlockRootSingleTxFirstRollupPrivateInputs }
   | { rollupType: 'rollup-block-root-first-empty-tx'; inputs: BlockRootEmptyTxFirstRollupPrivateInputs }
+  | { rollupType: 'rollup-block-root-msgs-only'; inputs: BlockRootMsgsOnlyRollupPrivateInputs }
   | { rollupType: 'rollup-block-root-single-tx'; inputs: BlockRootSingleTxRollupPrivateInputs }
   | { rollupType: 'rollup-block-root'; inputs: BlockRootRollupPrivateInputs };
 
@@ -74,6 +76,9 @@ export class BlockProvingState {
     private readonly timestamp: UInt64,
     public readonly lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
     private readonly lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    // The full state reference of the previous block, before this block's bundle is appended. Feeds the msgs-only
+    // block root, whose zero-tx block has no tx constants to pin the previous state.
+    private readonly previousState: StateReference,
     // This block's L1-to-L2 message tree snapshot before and after its own bundle (AZIP-22 Fast Inbox). The start is
     // the previous block's end (block-merge continuity); the end is this block's own post-bundle snapshot.
     private readonly startL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
@@ -82,18 +87,31 @@ export class BlockProvingState {
     private readonly l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>,
     // This block's own real L1-to-L2 message leaves (unpadded slice).
     private readonly l1ToL2Messages: Fr[],
+    // Message sponge threaded across the checkpoint's blocks (AZIP-22 Fast Inbox): the start is the previous block's
+    // end sponge (empty for the first block), the end absorbs this block's own slice. Block merges assert the
+    // continuity, so the end is exposed for the next block to inherit.
+    private readonly startMsgSponge: L1ToL2MessageSponge,
+    private readonly endMsgSponge: L1ToL2MessageSponge,
     private readonly headerOfLastBlockInPreviousCheckpoint: BlockHeader,
     private readonly startSpongeBlob: SpongeBlob,
     public parentCheckpoint: CheckpointProvingState,
   ) {
     this.isFirstBlock = index === 0;
-    if (!totalNumTxs && !this.isFirstBlock) {
-      throw new Error(`Cannot create a block with 0 txs, unless it's the first block.`);
+    if (!totalNumTxs && !this.isFirstBlock && l1ToL2Messages.length === 0) {
+      throw new Error(
+        `Cannot create a non-first block with 0 txs and no L1-to-L2 messages (block ${blockNumber}). ` +
+          `A zero-tx non-first block must carry a message bundle (the msgs-only block root).`,
+      );
     }
 
     this.baseOrMergeProofs = new UnbalancedTreeStore(totalNumTxs);
   }
 
+  /** The message sponge after absorbing this block's slice; inherited by the next block as its start sponge. */
+  public getEndMsgSponge(): L1ToL2MessageSponge {
+    return this.endMsgSponge;
+  }
+
   public get epochNumber(): number {
     return this.parentCheckpoint.epochNumber;
   }
@@ -305,7 +323,25 @@ export class BlockProvingState {
 
     const messageBundle = this.#getMessageBundle();
     const frontierHint = this.#getFrontierHint();
-    const startMsgSponge = this.parentCheckpoint.getCheckpointMsgSponge();
+    const startMsgSponge = this.startMsgSponge;
+
+    // A non-first block with no txs exists solely to insert its message bundle (the constructor rejects an empty one).
+    if (this.totalNumTxs === 0) {
+      return {
+        rollupType: 'rollup-block-root-msgs-only' satisfies CircuitName,
+        inputs: new BlockRootMsgsOnlyRollupPrivateInputs(
+          this.lastArchiveTreeSnapshot,
+          this.previousState,
+          this.constants,
+          this.timestamp,
+          this.startSpongeBlob,
+          startMsgSponge,
+          messageBundle,
+          frontierHint,
+          this.lastArchiveSiblingPath,
+        ),
+      };
+    }
 
     const [leftRollup, rightRollup] = previousRollups;
     if (!rightRollup) {
diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
index 8ee56863cd69..cf9afdd43b05 100644
--- a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
+++ b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts
@@ -14,7 +14,7 @@ import { L1ToL2MessageSponge } from '@aztec/stdlib/messaging';
 import { InboxParityPrivateInputs, type ParityPublicInputs } from '@aztec/stdlib/parity';
 import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { BlockHeader, StateReference } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
 import { toProofData } from './block-building-helpers.js';
@@ -42,10 +42,6 @@ export class CheckpointProvingState {
     // Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end value; genesis is zero).
     // Threaded into the InboxParity circuit so the resulting checkpoint header rolling hash matches the proposer's.
     private readonly startInboxRollingHash: Fr,
-    // Message-bundle sponge over the checkpoint's real messages (real-count absorb). Equals the InboxParity proof's
-    // end sponge and the sponge the block roots accumulate, so it is threaded into non-first block roots as their
-    // inherited `startMsgSponge`.
-    private readonly checkpointMsgSponge: L1ToL2MessageSponge,
     public readonly epochNumber: number,
     /** Owner's liveness check. `verifyState()` returns false once this returns false. */
     private readonly isAlive: () => boolean,
@@ -61,24 +57,22 @@ export class CheckpointProvingState {
     return this.l1ToL2Messages;
   }
 
-  /** The message-bundle sponge over the checkpoint's real messages (real-count absorb) — inherited by non-first block roots. */
-  public getCheckpointMsgSponge(): L1ToL2MessageSponge {
-    return this.checkpointMsgSponge;
-  }
-
-  public startNewBlock(
+  public async startNewBlock(
     blockNumber: BlockNumber,
     timestamp: UInt64,
     totalNumTxs: number,
     lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
     lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    // The full state reference of the previous block (before this block's message bundle is appended). Feeds the
+    // msgs-only block root, whose zero-tx block carries no tx constants to pin the previous state.
+    previousState: StateReference,
     // Per-block L1-to-L2 message state (AZIP-22 Fast Inbox): the block's start snapshot (its parent's end), its own
     // post-bundle end snapshot, the full-height frontier at the start index, and its own real message slice.
     startL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
     endL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
     l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>,
     l1ToL2Messages: Fr[],
-  ): BlockProvingState {
+  ): Promise<BlockProvingState> {
     const index = Number(blockNumber) - Number(this.firstBlockNumber);
     if (index >= this.totalNumBlocks) {
       throw new Error(`Unable to start a new block at index ${index}. Expected at most ${this.totalNumBlocks} blocks.`);
@@ -91,6 +85,19 @@ export class CheckpointProvingState {
       );
     }
 
+    // Thread the message sponge across the checkpoint's blocks (AZIP-22 Fast Inbox): each block starts from the
+    // previous block's end sponge (empty for the first block) and absorbs its own real slice. The block merge and
+    // checkpoint root circuits assert exactly this continuity (`right.start_msg_sponge == left.end_msg_sponge`, first
+    // block starts empty, merged end equals the InboxParity sponge), so the end sponge is computed eagerly here for
+    // the next block to inherit. Blocks must therefore be started in order, which the sequential per-block message
+    // appends already require.
+    const startMsgSponge = index === 0 ? L1ToL2MessageSponge.empty() : this.blocks[index - 1]?.getEndMsgSponge();
+    if (!startMsgSponge) {
+      throw new Error('Cannot start a new block before the previous block in the checkpoint has been started.');
+    }
+    const endMsgSponge = startMsgSponge.clone();
+    await endMsgSponge.absorb(l1ToL2Messages);
+
     const block = new BlockProvingState(
       index,
       blockNumber,
@@ -99,10 +106,13 @@ export class CheckpointProvingState {
       timestamp,
       lastArchiveTreeSnapshot,
       lastArchiveSiblingPath,
+      previousState,
       startL1ToL2MessageTreeSnapshot,
       endL1ToL2MessageTreeSnapshot,
       l1ToL2MessageFrontierHint,
       l1ToL2Messages,
+      startMsgSponge,
+      endMsgSponge,
       this.headerOfLastBlockInPreviousCheckpoint,
       startSpongeBlob,
       this,
diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
index dabe0bf452b1..b7876982d032 100644
--- a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
+++ b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts
@@ -20,7 +20,7 @@ import type {
   ReadonlyWorldStateAccess,
   ServerCircuitProver,
 } from '@aztec/stdlib/interfaces/server';
-import { L1ToL2MessageSponge, appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
+import { appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
 import type { ParityPublicInputs } from '@aztec/stdlib/parity';
 import {
   type BaseRollupHints,
@@ -283,6 +283,10 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
     const lastArchiveTreeSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const lastArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
 
+    // The previous block's full state reference, captured before this block's message bundle is appended. Feeds the
+    // msgs-only block root, whose zero-tx block carries no tx constants to pin the previous state.
+    const previousState = await db.getStateReference();
+
     // Streaming Inbox (AZIP-22 Fast Inbox): insert this block's own real message slice at compact indices, capturing
     // the start snapshot + full-height frontier before the append and the block's own post-bundle end snapshot after.
     const startL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
@@ -293,12 +297,13 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
     await appendL1ToL2MessagesToTree(db, l1ToL2Messages);
     const endL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
 
-    const blockProvingState = this.provingState.startNewBlock(
+    const blockProvingState = await this.provingState.startNewBlock(
       blockNumber,
       timestamp,
       totalNumTxs,
       lastArchiveTreeSnapshot,
       lastArchiveSiblingPath,
+      previousState,
       startL1ToL2Snapshot,
       endL1ToL2Snapshot,
       l1ToL2FrontierHint,
@@ -318,8 +323,8 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
 
       // A block with no txs has no base or merge proof whose completion would enqueue its block root,
       // and parity now gates the checkpoint root rather than the first block root, so no other callback
-      // fires it. Enqueue it here. Only a first block may be empty (the block proving state rejects
-      // any other), so this always drives the empty-tx first block root.
+      // fires it. Enqueue it here. This drives the empty-tx first block root, or the msgs-only block root
+      // for a non-first zero-tx block carrying a message bundle.
       this.checkAndEnqueueBlockRootRollup(blockProvingState);
     }
   }
@@ -528,11 +533,8 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
     const lastArchiveSiblingPath = await getLastSiblingPath(MerkleTreeId.ARCHIVE, db);
 
     // Streaming Inbox (AZIP-22 Fast Inbox): messages are inserted per block in `startNewBlock`, not the whole
-    // checkpoint up front. The message sponge still absorbs the checkpoint's real messages (real-count), matching the
-    // checkpoint's single InboxParity proof; non-first block roots inherit this sponge.
-    const checkpointMsgSponge = L1ToL2MessageSponge.empty();
-    await checkpointMsgSponge.absorb(l1ToL2Messages);
-
+    // checkpoint up front. The message sponge is likewise threaded per block (each block's start sponge is the
+    // previous block's end), so the last block's end sponge matches the checkpoint's single InboxParity proof.
     this.provingState = new CheckpointProvingState(
       /* index */ 0,
       constants,
@@ -541,7 +543,6 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       lastArchiveSiblingPath,
       l1ToL2Messages,
       startInboxRollingHash,
-      checkpointMsgSponge,
       Number(this.epochNumber),
       /* isAlive */ () => !this.cancelled,
       /* onReject */ reason => this.subTreeResult.reject(new Error(reason)),
@@ -741,6 +742,8 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
               return this.prover.getBlockRootSingleTxFirstRollupProof(rollup.inputs, signal, provingState.epochNumber);
             case 'rollup-block-root-first-empty-tx':
               return this.prover.getBlockRootEmptyTxFirstRollupProof(rollup.inputs, signal, provingState.epochNumber);
+            case 'rollup-block-root-msgs-only':
+              return this.prover.getBlockRootMsgsOnlyRollupProof(rollup.inputs, signal, provingState.epochNumber);
             case 'rollup-block-root-single-tx':
               return this.prover.getBlockRootSingleTxRollupProof(rollup.inputs, signal, provingState.epochNumber);
             case 'rollup-block-root':
diff --git a/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts b/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts
index 31f948406db4..950d8a8ea691 100644
--- a/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts
+++ b/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts
@@ -615,6 +615,7 @@ describe('L1Publisher integration', () => {
           checkpoint,
           CommitteeAttestationsAndSigners.empty(getSignatureContext()),
           Signature.empty(),
+          0n,
         );
         // Align chain time so the bundle simulate and the L1 send both run at the header's slot.
         await progressToSlot(BigInt(checkpoint.header.slotNumber));
@@ -723,6 +724,7 @@ describe('L1Publisher integration', () => {
         checkpoint,
         new CommitteeAttestationsAndSigners(attestations, getSignatureContext()),
         signature,
+        0n,
       );
       // Align chain time so the bundle simulate and the L1 send both run at the header's slot.
       await progressToSlot(BigInt(checkpoint.header.slotNumber));
@@ -768,7 +770,7 @@ describe('L1Publisher integration', () => {
       // warn log carrying the on-chain revert reason (raw hex selector since the propose request
       // has no ABI attached).
       const loggerWarnSpy = jest.spyOn((publisher as any).log, 'warn');
-      await publisher.enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, Signature.empty());
+      await publisher.enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, Signature.empty(), 0n);
       await progressToSlot(BigInt(checkpoint.header.slotNumber));
       const result = await publisher.sendRequests();
       expect(result).toBeUndefined();
@@ -805,6 +807,7 @@ describe('L1Publisher integration', () => {
         checkpoint,
         attestationsAndSigners,
         flipSignature(attestationsAndSignersSignature),
+        0n,
       );
       await progressToSlot(BigInt(checkpoint.header.slotNumber));
       const result = await publisher.sendRequests();
@@ -844,7 +847,7 @@ describe('L1Publisher integration', () => {
       // Enqueue no longer simulates — the bundle simulate at send time drops the failing propose
       // and sendRequests returns undefined.
       const loggerWarnSpy = jest.spyOn((publisher as any).log, 'warn');
-      await publisher.enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, wrongSig);
+      await publisher.enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, wrongSig, 0n);
       await progressToSlot(BigInt(checkpoint.header.slotNumber));
       const result = await publisher.sendRequests();
       expect(result).toBeUndefined();
@@ -928,7 +931,7 @@ describe('L1Publisher integration', () => {
       // Invalidate and propose
       logger.warn('Enqueuing requests to invalidate and propose the checkpoint');
       publisher.enqueueInvalidateCheckpoint(invalidateRequest);
-      await publisher.enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, attestationsAndSignersSignature);
+      await publisher.enqueueProposeCheckpoint(checkpoint, attestationsAndSigners, attestationsAndSignersSignature, 0n);
       await progressToSlot(BigInt(checkpoint.header.slotNumber));
       const result = await publisher.sendRequests();
       expect(result!.successfulActions).toEqual(['invalidate-by-insufficient-attestations', 'propose']);
@@ -949,6 +952,7 @@ describe('L1Publisher integration', () => {
         checkpoint,
         CommitteeAttestationsAndSigners.empty(getSignatureContext()),
         Signature.empty(),
+        0n,
       );
       await publisher.enqueueGovernanceCastSignal(
         l1ContractAddresses.rollupAddress,
@@ -977,6 +981,7 @@ describe('L1Publisher integration', () => {
         checkpoint,
         CommitteeAttestationsAndSigners.empty(getSignatureContext()),
         Signature.empty(),
+        0n,
       );
       await progressToSlot(BigInt(checkpoint.header.slotNumber));
       const result = await publisher.sendRequests();
@@ -1033,6 +1038,7 @@ describe('L1Publisher integration', () => {
         checkpoint,
         CommitteeAttestationsAndSigners.empty(getSignatureContext()),
         Signature.empty(),
+        0n,
         { txTimeoutAt: getProposeTxTimeoutAt(checkpoint) },
       );
     };
diff --git a/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts b/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts
index 4221bf07219e..a159a0e6ff7d 100644
--- a/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts
+++ b/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts
@@ -259,6 +259,7 @@ describe('SequencerPublisher', () => {
       checkpoint,
       CommitteeAttestationsAndSigners.empty(testSignatureContext),
       Signature.empty(),
+      0n,
     );
 
     const { govPayload, voteSig } = mockGovernancePayload();
@@ -347,6 +348,7 @@ describe('SequencerPublisher', () => {
       new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
       CommitteeAttestationsAndSigners.empty(testSignatureContext),
       Signature.empty(),
+      0n,
     );
     const result = await publisher.sendRequests();
     expect(result).toEqual(undefined);
@@ -421,6 +423,7 @@ describe('SequencerPublisher', () => {
         new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
         CommitteeAttestationsAndSigners.empty(testSignatureContext),
         Signature.empty(),
+        0n,
       );
       const result = await rotatingPublisher.sendRequests();
 
@@ -457,6 +460,7 @@ describe('SequencerPublisher', () => {
         new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
         CommitteeAttestationsAndSigners.empty(testSignatureContext),
         Signature.empty(),
+        0n,
       );
       // TimeoutError propagates to the outer catch in sendRequests which returns undefined
       const result = await rotatingPublisher.sendRequests();
@@ -476,6 +480,7 @@ describe('SequencerPublisher', () => {
         new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
         CommitteeAttestationsAndSigners.empty(testSignatureContext),
         Signature.empty(),
+        0n,
       );
       const result = await rotatingPublisher.sendRequests();
 
@@ -490,6 +495,7 @@ describe('SequencerPublisher', () => {
         new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
         CommitteeAttestationsAndSigners.empty(testSignatureContext),
         Signature.empty(),
+        0n,
         { txTimeoutAt: pastTimeout },
       );
       const result = await rotatingPublisher.sendRequests();
@@ -522,6 +528,7 @@ describe('SequencerPublisher', () => {
           new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
           CommitteeAttestationsAndSigners.empty(testSignatureContext),
           Signature.empty(),
+          0n,
           { txTimeoutAt: futureTimeout },
         );
         const result = await rotatingPublisher.sendRequests();
@@ -544,6 +551,7 @@ describe('SequencerPublisher', () => {
         new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
         CommitteeAttestationsAndSigners.empty(testSignatureContext),
         Signature.empty(),
+        0n,
       );
       const result = await rotatingPublisher.sendRequests();
 
@@ -558,6 +566,7 @@ describe('SequencerPublisher', () => {
       new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
       CommitteeAttestationsAndSigners.empty(testSignatureContext),
       Signature.empty(),
+      0n,
     );
 
     // Simulate the bundle-level validate returning a failed entry for the propose call.
@@ -776,6 +785,7 @@ describe('SequencerPublisher', () => {
       new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
       CommitteeAttestationsAndSigners.empty(testSignatureContext),
       Signature.empty(),
+      0n,
     );
     publisher.interrupt();
     const resultPromise = publisher.sendRequests();
@@ -1161,6 +1171,7 @@ describe('SequencerPublisher', () => {
         new Checkpoint(l2Block.archive, header, [l2Block], l2Block.checkpointNumber),
         CommitteeAttestationsAndSigners.empty(testSignatureContext),
         Signature.empty(),
+        0n,
       );
 
       const result = await storedPublisher.sendRequests();
diff --git a/yarn-project/validator-client/src/proposal_handler.test.ts b/yarn-project/validator-client/src/proposal_handler.test.ts
index f6176a40bef1..d2b6302b1f5d 100644
--- a/yarn-project/validator-client/src/proposal_handler.test.ts
+++ b/yarn-project/validator-client/src/proposal_handler.test.ts
@@ -734,9 +734,9 @@ describe('ProposalHandler checkpoint validation', () => {
     });
   });
 
-  // AZIP-22 Fast Inbox: with `streamingInbox` on, a block proposal's L1-to-L2 bundle is derived from its bucket
-  // reference and gated by the four acceptance checks, replacing the legacy per-checkpoint inHash comparison.
-  describe('handleBlockProposal streaming inbox checks (flag on)', () => {
+  // AZIP-22 Fast Inbox: a block proposal's L1-to-L2 bundle is derived from its bucket reference and gated by the four
+  // acceptance checks, replacing the legacy per-checkpoint inHash comparison.
+  describe('handleBlockProposal streaming inbox checks', () => {
     const bucket = (overrides: Partial<InboxBucket> = {}): InboxBucket => ({
       seq: 1n,
       inboxRollingHash: new Fr(0xabc),
@@ -848,9 +848,9 @@ describe('ProposalHandler checkpoint validation', () => {
     });
   });
 
-  // AZIP-22 Fast Inbox: with `streamingInbox` on, the checkpoint handler enforces the last-block minimum-consumption
-  // (censorship) rule before attesting.
-  describe('checkpoint proposal last-block censorship (flag on)', () => {
+  // AZIP-22 Fast Inbox: the checkpoint handler enforces the last-block minimum-consumption (censorship) rule before
+  // attesting.
+  describe('checkpoint proposal last-block censorship', () => {
     /** Two-block checkpoint at slot 10 whose last block consumed through leaf count `lastBlockTotal`. */
     function setupCensorshipMocks(lastBlockTotal: number) {
       const archiveRoot = Fr.random();
diff --git a/yarn-project/validator-client/src/proposal_handler.ts b/yarn-project/validator-client/src/proposal_handler.ts
index 4abf8bb64ac5..dcec5f39ccc1 100644
--- a/yarn-project/validator-client/src/proposal_handler.ts
+++ b/yarn-project/validator-client/src/proposal_handler.ts
@@ -203,8 +203,8 @@ export const SLASHABLE_CHECKPOINT_PROPOSAL_VALIDATION_RESULT: Record<
   ['last_block_archive_mismatch']: true,
 
   // disabled
-  // Streaming Inbox last-block censorship: new and flag-gated (default off), so keep it out of slashing while the
-  // path lands; L1 `propose` is the authoritative reject (Rollup__UnconsumedInboxMessages) pre-flip.
+  // Streaming Inbox last-block censorship: kept out of slashing while the streaming path is new; L1 `propose` is the
+  // authoritative reject (Rollup__UnconsumedInboxMessages).
   ['inbox_consumption_insufficient']: false,
   ['invalid_signature']: false,
   ['last_block_not_found']: false,

From 7aa5ff0c470efea3d5f32f8c6da893cdff42f68f Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 12:27:27 -0300
Subject: [PATCH 11/22] fix(fast-inbox): bb full-rollup test respects the
 per-block message cap (A-1384)

Same bug as the regen-scenario fix: makeCheckpoint concentrates every message into the first block,
whose bundle pads to MAX_L1_TO_L2_MSGS_PER_BLOCK (256), so seeding the scenario with the
per-checkpoint 1024 threw at input construction.
---
 .../prover-client/src/test/bb_prover_full_rollup.test.ts     | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts b/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts
index 221d1620eab4..a00afd4cefbe 100644
--- a/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts
+++ b/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts
@@ -1,5 +1,5 @@
 import { BBNativeRollupProver, type BBProverConfig } from '@aztec/bb-prover';
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PAIRING_POINTS_SIZE } from '@aztec/constants';
+import { MAX_L1_TO_L2_MSGS_PER_BLOCK, PAIRING_POINTS_SIZE } from '@aztec/constants';
 import { EpochNumber } from '@aztec/foundation/branded-types';
 import { timesAsync } from '@aztec/foundation/collection';
 import { parseBooleanEnv } from '@aztec/foundation/config';
@@ -52,7 +52,8 @@ describe('prover/bb_prover/full-rollup', () => {
       const checkpoints = await timesAsync(numCheckpoints, () =>
         context.makeCheckpoint(numBlockPerCheckpoint, {
           numTxsPerBlock,
-          numL1ToL2Messages: NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+          // makeCheckpoint puts the whole message list into the first block, so cap at the per-block limit.
+          numL1ToL2Messages: MAX_L1_TO_L2_MSGS_PER_BLOCK,
           makeProcessedTxOpts: (_, txIndex) => ({ privateOnly: txIndex % 2 === 0 }),
         }),
       );

From bddd002994c7a5aaba4a4a0a21f5a3b446596a1c Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 13:29:39 -0300
Subject: [PATCH 12/22] feat(fast-inbox): a non-empty message bundle satisfies
 the block min-work threshold (A-1384)

A block with zero txs but a non-empty streaming Inbox bundle counts as having
work and is produced regardless of minTxsPerBlock (whose default stays 1), so
proposers drain the Inbox on an empty tx pool. Also default the test suite's
world-state fork and Inbox-bucket mocks for the now-unconditional streaming
cursor initialization.
---
 .../sequencer/checkpoint_proposal_job.test.ts | 48 +++++++++++++++++++
 .../src/sequencer/checkpoint_proposal_job.ts  | 11 +++--
 2 files changed, 55 insertions(+), 4 deletions(-)

diff --git a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts
index 33c9fb300a34..ce69a54cadb6 100644
--- a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts
+++ b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts
@@ -38,6 +38,7 @@ import {
   InsufficientValidTxsError,
   type MerkleTreeWriteOperations,
   type ResolvedSequencerConfig,
+  type TreeInfo,
   type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
 import type { InboxBucket, L1ToL2MessageSource } from '@aztec/stdlib/messaging';
@@ -229,6 +230,9 @@ describe('CheckpointProposalJob', () => {
     const mockFork = mock<MerkleTreeWriteOperations>({
       [Symbol.asyncDispose]: jest.fn().mockReturnValue(Promise.resolve()) as () => Promise<void>,
     });
+    // The streaming Inbox cursor resolves the parent bucket from the fork's L1-to-L2 tree leaf count; default to
+    // an empty tree so checkpoints start at the genesis bucket unless a test seeds buckets.
+    mockFork.getTreeInfo.mockResolvedValue({ size: 0n } as TreeInfo);
     worldState.fork.mockResolvedValue(mockFork);
 
     // Create fake CheckpointsBuilder and CheckpointBuilder
@@ -246,6 +250,17 @@ describe('CheckpointProposalJob', () => {
 
     l1ToL2MessageSource = mock<L1ToL2MessageSource>();
     l1ToL2MessageSource.getL1ToL2Messages.mockResolvedValue(Array(4).fill(Fr.ZERO));
+    // Genesis bucket for the empty-tree cursor above; with no newer synced buckets mocked, block bundle
+    // selection consumes nothing by default.
+    l1ToL2MessageSource.getInboxBucketByTotalMsgCount.mockResolvedValue({
+      seq: 0n,
+      inboxRollingHash: Fr.ZERO,
+      totalMsgCount: 0n,
+      timestamp: 0n,
+      msgCount: 0,
+      lastMessageIndex: 0n,
+      isOpen: false,
+    });
 
     l2BlockSource = mock<L2BlockSource>();
     l2BlockSource.getCheckpointsData.mockResolvedValue([]);
@@ -1445,6 +1460,39 @@ describe('CheckpointProposalJob', () => {
       expect(bucketRefArgs[0]?.bucketSeq).toBe(2n);
       expect(bucketRefArgs[1]?.bucketSeq).toBe(2n);
     });
+
+    it('produces a message-only block when a non-empty bundle is selected and no txs are pending', async () => {
+      jest
+        .spyOn(job.getTimetable(), 'selectNextSubslot')
+        .mockReturnValueOnce(subslot(10, 0, true))
+        .mockReturnValue(noSubslot());
+
+      const bucket: InboxBucket = {
+        seq: 2n,
+        inboxRollingHash: new Fr(99),
+        totalMsgCount: 5n,
+        timestamp: 0n,
+        msgCount: 2,
+        lastMessageIndex: 4n,
+        isOpen: false,
+      };
+      const bundle = Array.from({ length: 5 }, (_, i) => new Fr(i + 1));
+      l1ToL2MessageSource.getLatestInboxBucketAtOrBefore.mockResolvedValue(bucket);
+      l1ToL2MessageSource.getL1ToL2MessagesBetweenBuckets.mockResolvedValue(bundle);
+
+      // Empty tx pool with the min-txs threshold at its default of one and no empty-checkpoint building: the
+      // non-empty bundle alone must count as work, producing a zero-tx (message-only) block.
+      const { lastBlock } = await setupMultipleBlocks(1, [0]);
+      validatorClient.collectAttestations.mockResolvedValue(getAttestations(lastBlock));
+
+      job.updateConfig({ minTxsPerBlock: 1, buildCheckpointIfEmpty: false });
+      const checkpoint = await job.executeAndAwait();
+
+      expect(checkpoint).toBeDefined();
+      expect(checkpointBuilder.buildBlockCalls).toHaveLength(1);
+      expect(checkpointBuilder.buildBlockCalls[0].opts.l1ToL2Messages).toEqual(bundle);
+      expect(publisher.enqueueProposeCheckpoint).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe('build single block', () => {
diff --git a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
index 798edd6735b8..8c34ec94d14c 100644
--- a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
+++ b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
@@ -1383,11 +1383,14 @@ export class CheckpointProposalJob implements Traceable {
   }): Promise<{ canStartBuilding: boolean; minTxs: number }> {
     const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
 
-    // A non-first block normally needs >= 1 tx to avoid empty filler blocks, but a message-only block (a non-empty
-    // streaming Inbox bundle) may carry zero txs (AZIP-22 Fast Inbox).
+    // A non-empty streaming Inbox bundle is work on its own: the block must be produced even with zero txs,
+    // regardless of minTxsPerBlock, so the messages get inserted (message-only block, AZIP-22 Fast Inbox).
+    // Without a bundle, a non-first block needs at least one tx to avoid empty filler blocks even when
+    // minTxsPerBlock is zero.
     const hasStreamingBundle = (opts.l1ToL2Messages?.length ?? 0) > 0;
-    const minTxs =
-      indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 && !hasStreamingBundle
+    const minTxs = hasStreamingBundle
+      ? 0
+      : indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0
         ? 1
         : this.config.minTxsPerBlock;
 

From 5759422685ca4161879538c0960b9bcfeaa3f7b6 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 13:29:39 -0300
Subject: [PATCH 13/22] chore(fast-inbox): drop unused isFirstBlock param from
 buildHeaderAndBodyFromTxs (A-1384)

The per-block blob-root change made every block carry its own post-bundle
l1-to-l2 root, leaving the flag unused.
---
 .../prover-client/src/light/lightweight_checkpoint_builder.ts   | 2 +-
 .../prover-client/src/orchestrator/block-building-helpers.ts    | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
index 446a957b001f..7db33683852c 100644
--- a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
+++ b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts
@@ -230,7 +230,7 @@ export class LightweightCheckpointBuilder {
     }
 
     const [msBuildHeaderAndBody, { header, body, blockBlobFields }] = await elapsed(() =>
-      buildHeaderAndBodyFromTxs(txs, lastArchive, endState, globalVariables, this.spongeBlob, isFirstBlock),
+      buildHeaderAndBodyFromTxs(txs, lastArchive, endState, globalVariables, this.spongeBlob),
     );
     timings.buildHeaderAndBody = msBuildHeaderAndBody;
 
diff --git a/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts b/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
index 08b347be56d6..3b17bc10cd31 100644
--- a/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
+++ b/yarn-project/prover-client/src/orchestrator/block-building-helpers.ts
@@ -312,7 +312,6 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
     endState: StateReference,
     globalVariables: GlobalVariables,
     startSpongeBlob: SpongeBlob,
-    isFirstBlock: boolean,
   ) => {
     span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
 

From c778cf39ba1870232888915ed895ece96260cbfb Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 13:29:39 -0300
Subject: [PATCH 14/22] chore(fast-inbox): fix solhint import order for
 SafeCast in ProposeLib (A-1384)

---
 l1-contracts/src/core/libraries/rollup/ProposeLib.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/l1-contracts/src/core/libraries/rollup/ProposeLib.sol b/l1-contracts/src/core/libraries/rollup/ProposeLib.sol
index 188d74e99db4..90aa72de0c39 100644
--- a/l1-contracts/src/core/libraries/rollup/ProposeLib.sol
+++ b/l1-contracts/src/core/libraries/rollup/ProposeLib.sol
@@ -18,9 +18,9 @@ import {ValidatorSelectionLib} from "@aztec/core/libraries/rollup/ValidatorSelec
 import {Timestamp, Slot, Epoch, TimeLib} from "@aztec/core/libraries/TimeLib.sol";
 import {CompressedSlot, CompressedTimeMath} from "@aztec/shared/libraries/CompressedTimeMath.sol";
 import {Signature} from "@aztec/shared/libraries/SignatureLib.sol";
+import {SafeCast} from "@oz/utils/math/SafeCast.sol";
 import {ProposedHeader, ProposedHeaderLib} from "./ProposedHeaderLib.sol";
 import {STFLib} from "./STFLib.sol";
-import {SafeCast} from "@oz/utils/math/SafeCast.sol";
 
 // Streaming-inbox protocol constants (AZIP-22 Fast Inbox). These mirror the protocol circuit constants and
 // should move into the generated Constants library once the Solidity emitter includes them.

From ff802fbcda2e599d34780170494e0164a14f378a Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 13:42:21 -0300
Subject: [PATCH 15/22] fix(fast-inbox): typecheck fixes for the streaming flip
 (A-1384)

- import BlockHeader from @aztec/stdlib/tx in prover-node (stdlib/block never
  exported it)
- read the checkpoint proposal's consumed bucket from lastBlock.bucketRef
- widen the block-record binary search bounds to plain numbers
- carry bucketHint in the expected L1 propose args of the publisher tests
---
 .../aztec-node/src/modules/node_world_state_queries.ts        | 4 ++--
 yarn-project/prover-node/src/prover-node.ts                   | 2 +-
 .../src/publisher/l1_publisher.integration.test.ts            | 1 +
 .../src/publisher/sequencer-publisher.test.ts                 | 1 +
 .../sequencer-client/src/sequencer/checkpoint_proposal_job.ts | 2 +-
 5 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/yarn-project/aztec-node/src/modules/node_world_state_queries.ts b/yarn-project/aztec-node/src/modules/node_world_state_queries.ts
index 46d280da0403..ca2c7c8bb814 100644
--- a/yarn-project/aztec-node/src/modules/node_world_state_queries.ts
+++ b/yarn-project/aztec-node/src/modules/node_world_state_queries.ts
@@ -197,8 +197,8 @@ export class NodeWorldStateQueries {
 
   /** Binary-searches the block records for the first block whose L1-to-L2 tree leaf count exceeds `messageIndex`. */
   async #findBlockConsumingL1ToL2MessageIndex(messageIndex: bigint): Promise<BlockData | undefined> {
-    let lo = INITIAL_L2_BLOCK_NUM;
-    let hi = await this.blockSource.getBlockNumber();
+    let lo: number = INITIAL_L2_BLOCK_NUM;
+    let hi: number = await this.blockSource.getBlockNumber();
     let result: BlockData | undefined;
     while (lo <= hi) {
       const mid = lo + Math.floor((hi - lo) / 2);
diff --git a/yarn-project/prover-node/src/prover-node.ts b/yarn-project/prover-node/src/prover-node.ts
index c65f7021441f..59a9dcedb4ac 100644
--- a/yarn-project/prover-node/src/prover-node.ts
+++ b/yarn-project/prover-node/src/prover-node.ts
@@ -13,7 +13,6 @@ import { getLastSiblingPath } from '@aztec/prover-client/helpers';
 import { ChonkCache } from '@aztec/prover-client/orchestrator';
 import { type AvmSimulator, PublicProcessorFactory } from '@aztec/simulator/server';
 import {
-  type BlockHeader,
   EventDrivenL2BlockStream,
   type L2Block,
   type L2BlockId,
@@ -39,6 +38,7 @@ import {
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 import {
   L1Metrics,
   type TelemetryClient,
diff --git a/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts b/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts
index 950d8a8ea691..c5777e43d6b9 100644
--- a/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts
+++ b/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts
@@ -661,6 +661,7 @@ describe('L1Publisher integration', () => {
               oracleInput: {
                 feeAssetPriceModifier: 0n,
               },
+              bucketHint: 0n,
             },
             CommitteeAttestationsAndSigners.packAttestations([]),
             [],
diff --git a/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts b/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts
index a159a0e6ff7d..e5058d08c326 100644
--- a/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts
+++ b/yarn-project/sequencer-client/src/publisher/sequencer-publisher.test.ts
@@ -293,6 +293,7 @@ describe('SequencerPublisher', () => {
         oracleInput: {
           feeAssetPriceModifier: 0n,
         },
+        bucketHint: 0n,
       },
       CommitteeAttestationsAndSigners.packAttestations([]),
       [],
diff --git a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
index 8c34ec94d14c..26cefca047a1 100644
--- a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
+++ b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts
@@ -311,7 +311,7 @@ export class CheckpointProposalJob implements Traceable {
   ): Promise<void> {
     const { checkpoint } = broadcast;
     // The checkpoint's consumed Inbox bucket is the last block's bucket reference (undefined ⇒ genesis bucket 0).
-    const bucketHint = broadcast.proposal.bucketRef?.bucketSeq ?? 0n;
+    const bucketHint = broadcast.proposal.lastBlock?.bucketRef?.bucketSeq ?? 0n;
 
     try {
       // Wait for all votes actions, enqueued at the beginning, to resolve

From fc770204b3005a5a95c53c2e24b594e842ef87e6 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 14:34:11 -0300
Subject: [PATCH 16/22] test(fast-inbox): carry bucketHint in archiver
 propose-calldata fixtures (A-1384)

The L1 ProposeArgs gained bucketHint at the flip; the archiver's fake L1
state and calldata-retriever fixtures must encode it too.
---
 yarn-project/archiver/src/l1/calldata_retriever.test.ts | 2 ++
 yarn-project/archiver/src/test/fake_l1_state.ts         | 1 +
 2 files changed, 3 insertions(+)

diff --git a/yarn-project/archiver/src/l1/calldata_retriever.test.ts b/yarn-project/archiver/src/l1/calldata_retriever.test.ts
index 716c3cb23b22..10a2103cc253 100644
--- a/yarn-project/archiver/src/l1/calldata_retriever.test.ts
+++ b/yarn-project/archiver/src/l1/calldata_retriever.test.ts
@@ -140,6 +140,7 @@ describe('CalldataRetriever', () => {
           archive,
           oracleInput: { feeAssetPriceModifier: BigInt(0) },
           header: viemHeader,
+          bucketHint: 0n,
         },
         attestations,
         signers,
@@ -368,6 +369,7 @@ describe('CalldataRetriever', () => {
             archive,
             oracleInput: { feeAssetPriceModifier },
             header,
+            bucketHint: 0n,
           },
           attestations,
           [], // signers
diff --git a/yarn-project/archiver/src/test/fake_l1_state.ts b/yarn-project/archiver/src/test/fake_l1_state.ts
index 28226f12020b..c37c050f906a 100644
--- a/yarn-project/archiver/src/test/fake_l1_state.ts
+++ b/yarn-project/archiver/src/test/fake_l1_state.ts
@@ -746,6 +746,7 @@ export class FakeL1State {
           header,
           archive,
           oracleInput: { feeAssetPriceModifier: 0n },
+          bucketHint: 0n,
         },
         verbatimAttestations,
         attestationsAndSigners.getSigners().map(signer => signer.toString()),

From 952ae471707c69c056bed163fa81b7f72c2a95b1 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 14:41:06 -0300
Subject: [PATCH 17/22] chore(fast-inbox): format validator config after
 streaming flag removal (A-1384)

---
 yarn-project/validator-client/src/config.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/yarn-project/validator-client/src/config.ts b/yarn-project/validator-client/src/config.ts
index 8237ab2664a3..38d914a6d6af 100644
--- a/yarn-project/validator-client/src/config.ts
+++ b/yarn-project/validator-client/src/config.ts
@@ -123,8 +123,7 @@ export const validatorClientConfigMappings: ConfigMappingsType<
  * Note: If an environment variable is not set, the default value is used.
  * @returns The validator configuration.
  */
-export function getProverEnvVars(): ValidatorClientConfig &
-  Pick<SequencerConfig, 'blockDurationMs'> {
+export function getProverEnvVars(): ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'> {
   return getConfigFromMappings<ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'>>(
     validatorClientConfigMappings,
   );

From f2d7cb1690caa8c95a9a20fb4dbf3f504a21584e Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 14:47:42 -0300
Subject: [PATCH 18/22] fix(fast-inbox): regen scenarios respect the per-block
 message cap (A-1384)

The flip drops the per-block bundle to 256 messages; the sample-input regen
scenarios put the whole message list into the first block, so cap them at one
per-block bundle.
---
 .../src/test/regenerate_rollup_sample_inputs.test.ts        | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts b/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts
index ee96d1889046..c764a978cb15 100644
--- a/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts
+++ b/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts
@@ -1,4 +1,4 @@
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { MAX_L1_TO_L2_MSGS_PER_BLOCK } from '@aztec/constants';
 import { EpochNumber } from '@aztec/foundation/branded-types';
 import { timesAsync } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -45,7 +45,9 @@ describeOrSkip('prover/regenerate-rollup-sample-inputs', () => {
     dump: CircuitName[];
   }
 
-  const withMessages = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP;
+  // `makeCheckpoint` puts the scenario's whole message list into the first block, so the most a
+  // scenario can carry is one full per-block bundle, not the per-checkpoint cap.
+  const withMessages = MAX_L1_TO_L2_MSGS_PER_BLOCK;
 
   const scenarios: Scenario[] = [
     {

From 1d633105b2a010943f276d7ccadf80881ed3ecc4 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 14:53:49 -0300
Subject: [PATCH 19/22] chore(fast-inbox): regenerate block-root sample inputs
 post-flip (A-1384)

The flip drops the per-block message cap to 256 and the previous_l1_to_l2
shape reaches all block-root flavors; regenerate the five crates' sample
inputs at this state.
---
 .../Prover.toml                               | 793 +---------------
 .../Prover.toml                               | 809 +---------------
 .../rollup-block-root-first/Prover.toml       | 837 +----------------
 .../rollup-block-root-single-tx/Prover.toml   | 843 +----------------
 .../crates/rollup-block-root/Prover.toml      | 871 +-----------------
 5 files changed, 154 insertions(+), 3999 deletions(-)

diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml
index b2bc95dd4c40..4c38c8316607 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml
@@ -2,15 +2,15 @@
 timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186"
 l1_to_l2_message_frontier_hint = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb",
+  "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d",
+  "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037",
+  "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da",
+  "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249",
+  "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f",
+  "0x221cf368938c74e4fced9dfb2a8e37cd8a6c57d21385c249f0b5c2412341287f",
+  "0x2c5214dfc4d70d2619fce2a7e02ddcf380576dca42b66c9215c7d8d1ec154116",
+  "0x13abc9bba431e6930c169f5daeb60aedbb27d7618c7ff88b3b4ec1c6de1d6bb8",
   "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f",
   "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad",
   "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da",
@@ -94,7 +94,7 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   [inputs.constants]
   chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
   version = "0x0000000000000000000000000000000000000000000000000000000000000000"
-  vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c"
+  vk_tree_root = "0x1d366660277d0da1e9c56a961b6d5b5cac2b74641eba14de96aff4f319db5556"
   protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b"
   prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
   slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f"
@@ -366,775 +366,6 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000000006d8",
   "0x00000000000000000000000000000000000000000000000000000000000006d9",
   "0x00000000000000000000000000000000000000000000000000000000000006da",
-  "0x00000000000000000000000000000000000000000000000000000000000006db",
-  "0x00000000000000000000000000000000000000000000000000000000000006dc",
-  "0x00000000000000000000000000000000000000000000000000000000000006dd",
-  "0x00000000000000000000000000000000000000000000000000000000000006de",
-  "0x00000000000000000000000000000000000000000000000000000000000006df",
-  "0x00000000000000000000000000000000000000000000000000000000000006e0",
-  "0x00000000000000000000000000000000000000000000000000000000000006e1",
-  "0x00000000000000000000000000000000000000000000000000000000000006e2",
-  "0x00000000000000000000000000000000000000000000000000000000000006e3",
-  "0x00000000000000000000000000000000000000000000000000000000000006e4",
-  "0x00000000000000000000000000000000000000000000000000000000000006e5",
-  "0x00000000000000000000000000000000000000000000000000000000000006e6",
-  "0x00000000000000000000000000000000000000000000000000000000000006e7",
-  "0x00000000000000000000000000000000000000000000000000000000000006e8",
-  "0x00000000000000000000000000000000000000000000000000000000000006e9",
-  "0x00000000000000000000000000000000000000000000000000000000000006ea",
-  "0x00000000000000000000000000000000000000000000000000000000000006eb",
-  "0x00000000000000000000000000000000000000000000000000000000000006ec",
-  "0x00000000000000000000000000000000000000000000000000000000000006ed",
-  "0x00000000000000000000000000000000000000000000000000000000000006ee",
-  "0x00000000000000000000000000000000000000000000000000000000000006ef",
-  "0x00000000000000000000000000000000000000000000000000000000000006f0",
-  "0x00000000000000000000000000000000000000000000000000000000000006f1",
-  "0x00000000000000000000000000000000000000000000000000000000000006f2",
-  "0x00000000000000000000000000000000000000000000000000000000000006f3",
-  "0x00000000000000000000000000000000000000000000000000000000000006f4",
-  "0x00000000000000000000000000000000000000000000000000000000000006f5",
-  "0x00000000000000000000000000000000000000000000000000000000000006f6",
-  "0x00000000000000000000000000000000000000000000000000000000000006f7",
-  "0x00000000000000000000000000000000000000000000000000000000000006f8",
-  "0x00000000000000000000000000000000000000000000000000000000000006f9",
-  "0x00000000000000000000000000000000000000000000000000000000000006fa",
-  "0x00000000000000000000000000000000000000000000000000000000000006fb",
-  "0x00000000000000000000000000000000000000000000000000000000000006fc",
-  "0x00000000000000000000000000000000000000000000000000000000000006fd",
-  "0x00000000000000000000000000000000000000000000000000000000000006fe",
-  "0x00000000000000000000000000000000000000000000000000000000000006ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000700",
-  "0x0000000000000000000000000000000000000000000000000000000000000701",
-  "0x0000000000000000000000000000000000000000000000000000000000000702",
-  "0x0000000000000000000000000000000000000000000000000000000000000703",
-  "0x0000000000000000000000000000000000000000000000000000000000000704",
-  "0x0000000000000000000000000000000000000000000000000000000000000705",
-  "0x0000000000000000000000000000000000000000000000000000000000000706",
-  "0x0000000000000000000000000000000000000000000000000000000000000707",
-  "0x0000000000000000000000000000000000000000000000000000000000000708",
-  "0x0000000000000000000000000000000000000000000000000000000000000709",
-  "0x000000000000000000000000000000000000000000000000000000000000070a",
-  "0x000000000000000000000000000000000000000000000000000000000000070b",
-  "0x000000000000000000000000000000000000000000000000000000000000070c",
-  "0x000000000000000000000000000000000000000000000000000000000000070d",
-  "0x000000000000000000000000000000000000000000000000000000000000070e",
-  "0x000000000000000000000000000000000000000000000000000000000000070f",
-  "0x0000000000000000000000000000000000000000000000000000000000000710",
-  "0x0000000000000000000000000000000000000000000000000000000000000711",
-  "0x0000000000000000000000000000000000000000000000000000000000000712",
-  "0x0000000000000000000000000000000000000000000000000000000000000713",
-  "0x0000000000000000000000000000000000000000000000000000000000000714",
-  "0x0000000000000000000000000000000000000000000000000000000000000715",
-  "0x0000000000000000000000000000000000000000000000000000000000000716",
-  "0x0000000000000000000000000000000000000000000000000000000000000717",
-  "0x0000000000000000000000000000000000000000000000000000000000000718",
-  "0x0000000000000000000000000000000000000000000000000000000000000719",
-  "0x000000000000000000000000000000000000000000000000000000000000071a",
-  "0x000000000000000000000000000000000000000000000000000000000000071b",
-  "0x000000000000000000000000000000000000000000000000000000000000071c",
-  "0x000000000000000000000000000000000000000000000000000000000000071d",
-  "0x000000000000000000000000000000000000000000000000000000000000071e",
-  "0x000000000000000000000000000000000000000000000000000000000000071f",
-  "0x0000000000000000000000000000000000000000000000000000000000000720",
-  "0x0000000000000000000000000000000000000000000000000000000000000721",
-  "0x0000000000000000000000000000000000000000000000000000000000000722",
-  "0x0000000000000000000000000000000000000000000000000000000000000723",
-  "0x0000000000000000000000000000000000000000000000000000000000000724",
-  "0x0000000000000000000000000000000000000000000000000000000000000725",
-  "0x0000000000000000000000000000000000000000000000000000000000000726",
-  "0x0000000000000000000000000000000000000000000000000000000000000727",
-  "0x0000000000000000000000000000000000000000000000000000000000000728",
-  "0x0000000000000000000000000000000000000000000000000000000000000729",
-  "0x000000000000000000000000000000000000000000000000000000000000072a",
-  "0x000000000000000000000000000000000000000000000000000000000000072b",
-  "0x000000000000000000000000000000000000000000000000000000000000072c",
-  "0x000000000000000000000000000000000000000000000000000000000000072d",
-  "0x000000000000000000000000000000000000000000000000000000000000072e",
-  "0x000000000000000000000000000000000000000000000000000000000000072f",
-  "0x0000000000000000000000000000000000000000000000000000000000000730",
-  "0x0000000000000000000000000000000000000000000000000000000000000731",
-  "0x0000000000000000000000000000000000000000000000000000000000000732",
-  "0x0000000000000000000000000000000000000000000000000000000000000733",
-  "0x0000000000000000000000000000000000000000000000000000000000000734",
-  "0x0000000000000000000000000000000000000000000000000000000000000735",
-  "0x0000000000000000000000000000000000000000000000000000000000000736",
-  "0x0000000000000000000000000000000000000000000000000000000000000737",
-  "0x0000000000000000000000000000000000000000000000000000000000000738",
-  "0x0000000000000000000000000000000000000000000000000000000000000739",
-  "0x000000000000000000000000000000000000000000000000000000000000073a",
-  "0x000000000000000000000000000000000000000000000000000000000000073b",
-  "0x000000000000000000000000000000000000000000000000000000000000073c",
-  "0x000000000000000000000000000000000000000000000000000000000000073d",
-  "0x000000000000000000000000000000000000000000000000000000000000073e",
-  "0x000000000000000000000000000000000000000000000000000000000000073f",
-  "0x0000000000000000000000000000000000000000000000000000000000000740",
-  "0x0000000000000000000000000000000000000000000000000000000000000741",
-  "0x0000000000000000000000000000000000000000000000000000000000000742",
-  "0x0000000000000000000000000000000000000000000000000000000000000743",
-  "0x0000000000000000000000000000000000000000000000000000000000000744",
-  "0x0000000000000000000000000000000000000000000000000000000000000745",
-  "0x0000000000000000000000000000000000000000000000000000000000000746",
-  "0x0000000000000000000000000000000000000000000000000000000000000747",
-  "0x0000000000000000000000000000000000000000000000000000000000000748",
-  "0x0000000000000000000000000000000000000000000000000000000000000749",
-  "0x000000000000000000000000000000000000000000000000000000000000074a",
-  "0x000000000000000000000000000000000000000000000000000000000000074b",
-  "0x000000000000000000000000000000000000000000000000000000000000074c",
-  "0x000000000000000000000000000000000000000000000000000000000000074d",
-  "0x000000000000000000000000000000000000000000000000000000000000074e",
-  "0x000000000000000000000000000000000000000000000000000000000000074f",
-  "0x0000000000000000000000000000000000000000000000000000000000000750",
-  "0x0000000000000000000000000000000000000000000000000000000000000751",
-  "0x0000000000000000000000000000000000000000000000000000000000000752",
-  "0x0000000000000000000000000000000000000000000000000000000000000753",
-  "0x0000000000000000000000000000000000000000000000000000000000000754",
-  "0x0000000000000000000000000000000000000000000000000000000000000755",
-  "0x0000000000000000000000000000000000000000000000000000000000000756",
-  "0x0000000000000000000000000000000000000000000000000000000000000757",
-  "0x0000000000000000000000000000000000000000000000000000000000000758",
-  "0x0000000000000000000000000000000000000000000000000000000000000759",
-  "0x000000000000000000000000000000000000000000000000000000000000075a",
-  "0x000000000000000000000000000000000000000000000000000000000000075b",
-  "0x000000000000000000000000000000000000000000000000000000000000075c",
-  "0x000000000000000000000000000000000000000000000000000000000000075d",
-  "0x000000000000000000000000000000000000000000000000000000000000075e",
-  "0x000000000000000000000000000000000000000000000000000000000000075f",
-  "0x0000000000000000000000000000000000000000000000000000000000000760",
-  "0x0000000000000000000000000000000000000000000000000000000000000761",
-  "0x0000000000000000000000000000000000000000000000000000000000000762",
-  "0x0000000000000000000000000000000000000000000000000000000000000763",
-  "0x0000000000000000000000000000000000000000000000000000000000000764",
-  "0x0000000000000000000000000000000000000000000000000000000000000765",
-  "0x0000000000000000000000000000000000000000000000000000000000000766",
-  "0x0000000000000000000000000000000000000000000000000000000000000767",
-  "0x0000000000000000000000000000000000000000000000000000000000000768",
-  "0x0000000000000000000000000000000000000000000000000000000000000769",
-  "0x000000000000000000000000000000000000000000000000000000000000076a",
-  "0x000000000000000000000000000000000000000000000000000000000000076b",
-  "0x000000000000000000000000000000000000000000000000000000000000076c",
-  "0x000000000000000000000000000000000000000000000000000000000000076d",
-  "0x000000000000000000000000000000000000000000000000000000000000076e",
-  "0x000000000000000000000000000000000000000000000000000000000000076f",
-  "0x0000000000000000000000000000000000000000000000000000000000000770",
-  "0x0000000000000000000000000000000000000000000000000000000000000771",
-  "0x0000000000000000000000000000000000000000000000000000000000000772",
-  "0x0000000000000000000000000000000000000000000000000000000000000773",
-  "0x0000000000000000000000000000000000000000000000000000000000000774",
-  "0x0000000000000000000000000000000000000000000000000000000000000775",
-  "0x0000000000000000000000000000000000000000000000000000000000000776",
-  "0x0000000000000000000000000000000000000000000000000000000000000777",
-  "0x0000000000000000000000000000000000000000000000000000000000000778",
-  "0x0000000000000000000000000000000000000000000000000000000000000779",
-  "0x000000000000000000000000000000000000000000000000000000000000077a",
-  "0x000000000000000000000000000000000000000000000000000000000000077b",
-  "0x000000000000000000000000000000000000000000000000000000000000077c",
-  "0x000000000000000000000000000000000000000000000000000000000000077d",
-  "0x000000000000000000000000000000000000000000000000000000000000077e",
-  "0x000000000000000000000000000000000000000000000000000000000000077f",
-  "0x0000000000000000000000000000000000000000000000000000000000000780",
-  "0x0000000000000000000000000000000000000000000000000000000000000781",
-  "0x0000000000000000000000000000000000000000000000000000000000000782",
-  "0x0000000000000000000000000000000000000000000000000000000000000783",
-  "0x0000000000000000000000000000000000000000000000000000000000000784",
-  "0x0000000000000000000000000000000000000000000000000000000000000785",
-  "0x0000000000000000000000000000000000000000000000000000000000000786",
-  "0x0000000000000000000000000000000000000000000000000000000000000787",
-  "0x0000000000000000000000000000000000000000000000000000000000000788",
-  "0x0000000000000000000000000000000000000000000000000000000000000789",
-  "0x000000000000000000000000000000000000000000000000000000000000078a",
-  "0x000000000000000000000000000000000000000000000000000000000000078b",
-  "0x000000000000000000000000000000000000000000000000000000000000078c",
-  "0x000000000000000000000000000000000000000000000000000000000000078d",
-  "0x000000000000000000000000000000000000000000000000000000000000078e",
-  "0x000000000000000000000000000000000000000000000000000000000000078f",
-  "0x0000000000000000000000000000000000000000000000000000000000000790",
-  "0x0000000000000000000000000000000000000000000000000000000000000791",
-  "0x0000000000000000000000000000000000000000000000000000000000000792",
-  "0x0000000000000000000000000000000000000000000000000000000000000793",
-  "0x0000000000000000000000000000000000000000000000000000000000000794",
-  "0x0000000000000000000000000000000000000000000000000000000000000795",
-  "0x0000000000000000000000000000000000000000000000000000000000000796",
-  "0x0000000000000000000000000000000000000000000000000000000000000797",
-  "0x0000000000000000000000000000000000000000000000000000000000000798",
-  "0x0000000000000000000000000000000000000000000000000000000000000799",
-  "0x000000000000000000000000000000000000000000000000000000000000079a",
-  "0x000000000000000000000000000000000000000000000000000000000000079b",
-  "0x000000000000000000000000000000000000000000000000000000000000079c",
-  "0x000000000000000000000000000000000000000000000000000000000000079d",
-  "0x000000000000000000000000000000000000000000000000000000000000079e",
-  "0x000000000000000000000000000000000000000000000000000000000000079f",
-  "0x00000000000000000000000000000000000000000000000000000000000007a0",
-  "0x00000000000000000000000000000000000000000000000000000000000007a1",
-  "0x00000000000000000000000000000000000000000000000000000000000007a2",
-  "0x00000000000000000000000000000000000000000000000000000000000007a3",
-  "0x00000000000000000000000000000000000000000000000000000000000007a4",
-  "0x00000000000000000000000000000000000000000000000000000000000007a5",
-  "0x00000000000000000000000000000000000000000000000000000000000007a6",
-  "0x00000000000000000000000000000000000000000000000000000000000007a7",
-  "0x00000000000000000000000000000000000000000000000000000000000007a8",
-  "0x00000000000000000000000000000000000000000000000000000000000007a9",
-  "0x00000000000000000000000000000000000000000000000000000000000007aa",
-  "0x00000000000000000000000000000000000000000000000000000000000007ab",
-  "0x00000000000000000000000000000000000000000000000000000000000007ac",
-  "0x00000000000000000000000000000000000000000000000000000000000007ad",
-  "0x00000000000000000000000000000000000000000000000000000000000007ae",
-  "0x00000000000000000000000000000000000000000000000000000000000007af",
-  "0x00000000000000000000000000000000000000000000000000000000000007b0",
-  "0x00000000000000000000000000000000000000000000000000000000000007b1",
-  "0x00000000000000000000000000000000000000000000000000000000000007b2",
-  "0x00000000000000000000000000000000000000000000000000000000000007b3",
-  "0x00000000000000000000000000000000000000000000000000000000000007b4",
-  "0x00000000000000000000000000000000000000000000000000000000000007b5",
-  "0x00000000000000000000000000000000000000000000000000000000000007b6",
-  "0x00000000000000000000000000000000000000000000000000000000000007b7",
-  "0x00000000000000000000000000000000000000000000000000000000000007b8",
-  "0x00000000000000000000000000000000000000000000000000000000000007b9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ba",
-  "0x00000000000000000000000000000000000000000000000000000000000007bb",
-  "0x00000000000000000000000000000000000000000000000000000000000007bc",
-  "0x00000000000000000000000000000000000000000000000000000000000007bd",
-  "0x00000000000000000000000000000000000000000000000000000000000007be",
-  "0x00000000000000000000000000000000000000000000000000000000000007bf",
-  "0x00000000000000000000000000000000000000000000000000000000000007c0",
-  "0x00000000000000000000000000000000000000000000000000000000000007c1",
-  "0x00000000000000000000000000000000000000000000000000000000000007c2",
-  "0x00000000000000000000000000000000000000000000000000000000000007c3",
-  "0x00000000000000000000000000000000000000000000000000000000000007c4",
-  "0x00000000000000000000000000000000000000000000000000000000000007c5",
-  "0x00000000000000000000000000000000000000000000000000000000000007c6",
-  "0x00000000000000000000000000000000000000000000000000000000000007c7",
-  "0x00000000000000000000000000000000000000000000000000000000000007c8",
-  "0x00000000000000000000000000000000000000000000000000000000000007c9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ca",
-  "0x00000000000000000000000000000000000000000000000000000000000007cb",
-  "0x00000000000000000000000000000000000000000000000000000000000007cc",
-  "0x00000000000000000000000000000000000000000000000000000000000007cd",
-  "0x00000000000000000000000000000000000000000000000000000000000007ce",
-  "0x00000000000000000000000000000000000000000000000000000000000007cf",
-  "0x00000000000000000000000000000000000000000000000000000000000007d0",
-  "0x00000000000000000000000000000000000000000000000000000000000007d1",
-  "0x00000000000000000000000000000000000000000000000000000000000007d2",
-  "0x00000000000000000000000000000000000000000000000000000000000007d3",
-  "0x00000000000000000000000000000000000000000000000000000000000007d4",
-  "0x00000000000000000000000000000000000000000000000000000000000007d5",
-  "0x00000000000000000000000000000000000000000000000000000000000007d6",
-  "0x00000000000000000000000000000000000000000000000000000000000007d7",
-  "0x00000000000000000000000000000000000000000000000000000000000007d8",
-  "0x00000000000000000000000000000000000000000000000000000000000007d9",
-  "0x00000000000000000000000000000000000000000000000000000000000007da",
-  "0x00000000000000000000000000000000000000000000000000000000000007db",
-  "0x00000000000000000000000000000000000000000000000000000000000007dc",
-  "0x00000000000000000000000000000000000000000000000000000000000007dd",
-  "0x00000000000000000000000000000000000000000000000000000000000007de",
-  "0x00000000000000000000000000000000000000000000000000000000000007df",
-  "0x00000000000000000000000000000000000000000000000000000000000007e0",
-  "0x00000000000000000000000000000000000000000000000000000000000007e1",
-  "0x00000000000000000000000000000000000000000000000000000000000007e2",
-  "0x00000000000000000000000000000000000000000000000000000000000007e3",
-  "0x00000000000000000000000000000000000000000000000000000000000007e4",
-  "0x00000000000000000000000000000000000000000000000000000000000007e5",
-  "0x00000000000000000000000000000000000000000000000000000000000007e6",
-  "0x00000000000000000000000000000000000000000000000000000000000007e7",
-  "0x00000000000000000000000000000000000000000000000000000000000007e8",
-  "0x00000000000000000000000000000000000000000000000000000000000007e9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ea",
-  "0x00000000000000000000000000000000000000000000000000000000000007eb",
-  "0x00000000000000000000000000000000000000000000000000000000000007ec",
-  "0x00000000000000000000000000000000000000000000000000000000000007ed",
-  "0x00000000000000000000000000000000000000000000000000000000000007ee",
-  "0x00000000000000000000000000000000000000000000000000000000000007ef",
-  "0x00000000000000000000000000000000000000000000000000000000000007f0",
-  "0x00000000000000000000000000000000000000000000000000000000000007f1",
-  "0x00000000000000000000000000000000000000000000000000000000000007f2",
-  "0x00000000000000000000000000000000000000000000000000000000000007f3",
-  "0x00000000000000000000000000000000000000000000000000000000000007f4",
-  "0x00000000000000000000000000000000000000000000000000000000000007f5",
-  "0x00000000000000000000000000000000000000000000000000000000000007f6",
-  "0x00000000000000000000000000000000000000000000000000000000000007f7",
-  "0x00000000000000000000000000000000000000000000000000000000000007f8",
-  "0x00000000000000000000000000000000000000000000000000000000000007f9",
-  "0x00000000000000000000000000000000000000000000000000000000000007fa",
-  "0x00000000000000000000000000000000000000000000000000000000000007fb",
-  "0x00000000000000000000000000000000000000000000000000000000000007fc",
-  "0x00000000000000000000000000000000000000000000000000000000000007fd",
-  "0x00000000000000000000000000000000000000000000000000000000000007fe",
-  "0x00000000000000000000000000000000000000000000000000000000000007ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000800",
-  "0x0000000000000000000000000000000000000000000000000000000000000801",
-  "0x0000000000000000000000000000000000000000000000000000000000000802",
-  "0x0000000000000000000000000000000000000000000000000000000000000803",
-  "0x0000000000000000000000000000000000000000000000000000000000000804",
-  "0x0000000000000000000000000000000000000000000000000000000000000805",
-  "0x0000000000000000000000000000000000000000000000000000000000000806",
-  "0x0000000000000000000000000000000000000000000000000000000000000807",
-  "0x0000000000000000000000000000000000000000000000000000000000000808",
-  "0x0000000000000000000000000000000000000000000000000000000000000809",
-  "0x000000000000000000000000000000000000000000000000000000000000080a",
-  "0x000000000000000000000000000000000000000000000000000000000000080b",
-  "0x000000000000000000000000000000000000000000000000000000000000080c",
-  "0x000000000000000000000000000000000000000000000000000000000000080d",
-  "0x000000000000000000000000000000000000000000000000000000000000080e",
-  "0x000000000000000000000000000000000000000000000000000000000000080f",
-  "0x0000000000000000000000000000000000000000000000000000000000000810",
-  "0x0000000000000000000000000000000000000000000000000000000000000811",
-  "0x0000000000000000000000000000000000000000000000000000000000000812",
-  "0x0000000000000000000000000000000000000000000000000000000000000813",
-  "0x0000000000000000000000000000000000000000000000000000000000000814",
-  "0x0000000000000000000000000000000000000000000000000000000000000815",
-  "0x0000000000000000000000000000000000000000000000000000000000000816",
-  "0x0000000000000000000000000000000000000000000000000000000000000817",
-  "0x0000000000000000000000000000000000000000000000000000000000000818",
-  "0x0000000000000000000000000000000000000000000000000000000000000819",
-  "0x000000000000000000000000000000000000000000000000000000000000081a",
-  "0x000000000000000000000000000000000000000000000000000000000000081b",
-  "0x000000000000000000000000000000000000000000000000000000000000081c",
-  "0x000000000000000000000000000000000000000000000000000000000000081d",
-  "0x000000000000000000000000000000000000000000000000000000000000081e",
-  "0x000000000000000000000000000000000000000000000000000000000000081f",
-  "0x0000000000000000000000000000000000000000000000000000000000000820",
-  "0x0000000000000000000000000000000000000000000000000000000000000821",
-  "0x0000000000000000000000000000000000000000000000000000000000000822",
-  "0x0000000000000000000000000000000000000000000000000000000000000823",
-  "0x0000000000000000000000000000000000000000000000000000000000000824",
-  "0x0000000000000000000000000000000000000000000000000000000000000825",
-  "0x0000000000000000000000000000000000000000000000000000000000000826",
-  "0x0000000000000000000000000000000000000000000000000000000000000827",
-  "0x0000000000000000000000000000000000000000000000000000000000000828",
-  "0x0000000000000000000000000000000000000000000000000000000000000829",
-  "0x000000000000000000000000000000000000000000000000000000000000082a",
-  "0x000000000000000000000000000000000000000000000000000000000000082b",
-  "0x000000000000000000000000000000000000000000000000000000000000082c",
-  "0x000000000000000000000000000000000000000000000000000000000000082d",
-  "0x000000000000000000000000000000000000000000000000000000000000082e",
-  "0x000000000000000000000000000000000000000000000000000000000000082f",
-  "0x0000000000000000000000000000000000000000000000000000000000000830",
-  "0x0000000000000000000000000000000000000000000000000000000000000831",
-  "0x0000000000000000000000000000000000000000000000000000000000000832",
-  "0x0000000000000000000000000000000000000000000000000000000000000833",
-  "0x0000000000000000000000000000000000000000000000000000000000000834",
-  "0x0000000000000000000000000000000000000000000000000000000000000835",
-  "0x0000000000000000000000000000000000000000000000000000000000000836",
-  "0x0000000000000000000000000000000000000000000000000000000000000837",
-  "0x0000000000000000000000000000000000000000000000000000000000000838",
-  "0x0000000000000000000000000000000000000000000000000000000000000839",
-  "0x000000000000000000000000000000000000000000000000000000000000083a",
-  "0x000000000000000000000000000000000000000000000000000000000000083b",
-  "0x000000000000000000000000000000000000000000000000000000000000083c",
-  "0x000000000000000000000000000000000000000000000000000000000000083d",
-  "0x000000000000000000000000000000000000000000000000000000000000083e",
-  "0x000000000000000000000000000000000000000000000000000000000000083f",
-  "0x0000000000000000000000000000000000000000000000000000000000000840",
-  "0x0000000000000000000000000000000000000000000000000000000000000841",
-  "0x0000000000000000000000000000000000000000000000000000000000000842",
-  "0x0000000000000000000000000000000000000000000000000000000000000843",
-  "0x0000000000000000000000000000000000000000000000000000000000000844",
-  "0x0000000000000000000000000000000000000000000000000000000000000845",
-  "0x0000000000000000000000000000000000000000000000000000000000000846",
-  "0x0000000000000000000000000000000000000000000000000000000000000847",
-  "0x0000000000000000000000000000000000000000000000000000000000000848",
-  "0x0000000000000000000000000000000000000000000000000000000000000849",
-  "0x000000000000000000000000000000000000000000000000000000000000084a",
-  "0x000000000000000000000000000000000000000000000000000000000000084b",
-  "0x000000000000000000000000000000000000000000000000000000000000084c",
-  "0x000000000000000000000000000000000000000000000000000000000000084d",
-  "0x000000000000000000000000000000000000000000000000000000000000084e",
-  "0x000000000000000000000000000000000000000000000000000000000000084f",
-  "0x0000000000000000000000000000000000000000000000000000000000000850",
-  "0x0000000000000000000000000000000000000000000000000000000000000851",
-  "0x0000000000000000000000000000000000000000000000000000000000000852",
-  "0x0000000000000000000000000000000000000000000000000000000000000853",
-  "0x0000000000000000000000000000000000000000000000000000000000000854",
-  "0x0000000000000000000000000000000000000000000000000000000000000855",
-  "0x0000000000000000000000000000000000000000000000000000000000000856",
-  "0x0000000000000000000000000000000000000000000000000000000000000857",
-  "0x0000000000000000000000000000000000000000000000000000000000000858",
-  "0x0000000000000000000000000000000000000000000000000000000000000859",
-  "0x000000000000000000000000000000000000000000000000000000000000085a",
-  "0x000000000000000000000000000000000000000000000000000000000000085b",
-  "0x000000000000000000000000000000000000000000000000000000000000085c",
-  "0x000000000000000000000000000000000000000000000000000000000000085d",
-  "0x000000000000000000000000000000000000000000000000000000000000085e",
-  "0x000000000000000000000000000000000000000000000000000000000000085f",
-  "0x0000000000000000000000000000000000000000000000000000000000000860",
-  "0x0000000000000000000000000000000000000000000000000000000000000861",
-  "0x0000000000000000000000000000000000000000000000000000000000000862",
-  "0x0000000000000000000000000000000000000000000000000000000000000863",
-  "0x0000000000000000000000000000000000000000000000000000000000000864",
-  "0x0000000000000000000000000000000000000000000000000000000000000865",
-  "0x0000000000000000000000000000000000000000000000000000000000000866",
-  "0x0000000000000000000000000000000000000000000000000000000000000867",
-  "0x0000000000000000000000000000000000000000000000000000000000000868",
-  "0x0000000000000000000000000000000000000000000000000000000000000869",
-  "0x000000000000000000000000000000000000000000000000000000000000086a",
-  "0x000000000000000000000000000000000000000000000000000000000000086b",
-  "0x000000000000000000000000000000000000000000000000000000000000086c",
-  "0x000000000000000000000000000000000000000000000000000000000000086d",
-  "0x000000000000000000000000000000000000000000000000000000000000086e",
-  "0x000000000000000000000000000000000000000000000000000000000000086f",
-  "0x0000000000000000000000000000000000000000000000000000000000000870",
-  "0x0000000000000000000000000000000000000000000000000000000000000871",
-  "0x0000000000000000000000000000000000000000000000000000000000000872",
-  "0x0000000000000000000000000000000000000000000000000000000000000873",
-  "0x0000000000000000000000000000000000000000000000000000000000000874",
-  "0x0000000000000000000000000000000000000000000000000000000000000875",
-  "0x0000000000000000000000000000000000000000000000000000000000000876",
-  "0x0000000000000000000000000000000000000000000000000000000000000877",
-  "0x0000000000000000000000000000000000000000000000000000000000000878",
-  "0x0000000000000000000000000000000000000000000000000000000000000879",
-  "0x000000000000000000000000000000000000000000000000000000000000087a",
-  "0x000000000000000000000000000000000000000000000000000000000000087b",
-  "0x000000000000000000000000000000000000000000000000000000000000087c",
-  "0x000000000000000000000000000000000000000000000000000000000000087d",
-  "0x000000000000000000000000000000000000000000000000000000000000087e",
-  "0x000000000000000000000000000000000000000000000000000000000000087f",
-  "0x0000000000000000000000000000000000000000000000000000000000000880",
-  "0x0000000000000000000000000000000000000000000000000000000000000881",
-  "0x0000000000000000000000000000000000000000000000000000000000000882",
-  "0x0000000000000000000000000000000000000000000000000000000000000883",
-  "0x0000000000000000000000000000000000000000000000000000000000000884",
-  "0x0000000000000000000000000000000000000000000000000000000000000885",
-  "0x0000000000000000000000000000000000000000000000000000000000000886",
-  "0x0000000000000000000000000000000000000000000000000000000000000887",
-  "0x0000000000000000000000000000000000000000000000000000000000000888",
-  "0x0000000000000000000000000000000000000000000000000000000000000889",
-  "0x000000000000000000000000000000000000000000000000000000000000088a",
-  "0x000000000000000000000000000000000000000000000000000000000000088b",
-  "0x000000000000000000000000000000000000000000000000000000000000088c",
-  "0x000000000000000000000000000000000000000000000000000000000000088d",
-  "0x000000000000000000000000000000000000000000000000000000000000088e",
-  "0x000000000000000000000000000000000000000000000000000000000000088f",
-  "0x0000000000000000000000000000000000000000000000000000000000000890",
-  "0x0000000000000000000000000000000000000000000000000000000000000891",
-  "0x0000000000000000000000000000000000000000000000000000000000000892",
-  "0x0000000000000000000000000000000000000000000000000000000000000893",
-  "0x0000000000000000000000000000000000000000000000000000000000000894",
-  "0x0000000000000000000000000000000000000000000000000000000000000895",
-  "0x0000000000000000000000000000000000000000000000000000000000000896",
-  "0x0000000000000000000000000000000000000000000000000000000000000897",
-  "0x0000000000000000000000000000000000000000000000000000000000000898",
-  "0x0000000000000000000000000000000000000000000000000000000000000899",
-  "0x000000000000000000000000000000000000000000000000000000000000089a",
-  "0x000000000000000000000000000000000000000000000000000000000000089b",
-  "0x000000000000000000000000000000000000000000000000000000000000089c",
-  "0x000000000000000000000000000000000000000000000000000000000000089d",
-  "0x000000000000000000000000000000000000000000000000000000000000089e",
-  "0x000000000000000000000000000000000000000000000000000000000000089f",
-  "0x00000000000000000000000000000000000000000000000000000000000008a0",
-  "0x00000000000000000000000000000000000000000000000000000000000008a1",
-  "0x00000000000000000000000000000000000000000000000000000000000008a2",
-  "0x00000000000000000000000000000000000000000000000000000000000008a3",
-  "0x00000000000000000000000000000000000000000000000000000000000008a4",
-  "0x00000000000000000000000000000000000000000000000000000000000008a5",
-  "0x00000000000000000000000000000000000000000000000000000000000008a6",
-  "0x00000000000000000000000000000000000000000000000000000000000008a7",
-  "0x00000000000000000000000000000000000000000000000000000000000008a8",
-  "0x00000000000000000000000000000000000000000000000000000000000008a9",
-  "0x00000000000000000000000000000000000000000000000000000000000008aa",
-  "0x00000000000000000000000000000000000000000000000000000000000008ab",
-  "0x00000000000000000000000000000000000000000000000000000000000008ac",
-  "0x00000000000000000000000000000000000000000000000000000000000008ad",
-  "0x00000000000000000000000000000000000000000000000000000000000008ae",
-  "0x00000000000000000000000000000000000000000000000000000000000008af",
-  "0x00000000000000000000000000000000000000000000000000000000000008b0",
-  "0x00000000000000000000000000000000000000000000000000000000000008b1",
-  "0x00000000000000000000000000000000000000000000000000000000000008b2",
-  "0x00000000000000000000000000000000000000000000000000000000000008b3",
-  "0x00000000000000000000000000000000000000000000000000000000000008b4",
-  "0x00000000000000000000000000000000000000000000000000000000000008b5",
-  "0x00000000000000000000000000000000000000000000000000000000000008b6",
-  "0x00000000000000000000000000000000000000000000000000000000000008b7",
-  "0x00000000000000000000000000000000000000000000000000000000000008b8",
-  "0x00000000000000000000000000000000000000000000000000000000000008b9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ba",
-  "0x00000000000000000000000000000000000000000000000000000000000008bb",
-  "0x00000000000000000000000000000000000000000000000000000000000008bc",
-  "0x00000000000000000000000000000000000000000000000000000000000008bd",
-  "0x00000000000000000000000000000000000000000000000000000000000008be",
-  "0x00000000000000000000000000000000000000000000000000000000000008bf",
-  "0x00000000000000000000000000000000000000000000000000000000000008c0",
-  "0x00000000000000000000000000000000000000000000000000000000000008c1",
-  "0x00000000000000000000000000000000000000000000000000000000000008c2",
-  "0x00000000000000000000000000000000000000000000000000000000000008c3",
-  "0x00000000000000000000000000000000000000000000000000000000000008c4",
-  "0x00000000000000000000000000000000000000000000000000000000000008c5",
-  "0x00000000000000000000000000000000000000000000000000000000000008c6",
-  "0x00000000000000000000000000000000000000000000000000000000000008c7",
-  "0x00000000000000000000000000000000000000000000000000000000000008c8",
-  "0x00000000000000000000000000000000000000000000000000000000000008c9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ca",
-  "0x00000000000000000000000000000000000000000000000000000000000008cb",
-  "0x00000000000000000000000000000000000000000000000000000000000008cc",
-  "0x00000000000000000000000000000000000000000000000000000000000008cd",
-  "0x00000000000000000000000000000000000000000000000000000000000008ce",
-  "0x00000000000000000000000000000000000000000000000000000000000008cf",
-  "0x00000000000000000000000000000000000000000000000000000000000008d0",
-  "0x00000000000000000000000000000000000000000000000000000000000008d1",
-  "0x00000000000000000000000000000000000000000000000000000000000008d2",
-  "0x00000000000000000000000000000000000000000000000000000000000008d3",
-  "0x00000000000000000000000000000000000000000000000000000000000008d4",
-  "0x00000000000000000000000000000000000000000000000000000000000008d5",
-  "0x00000000000000000000000000000000000000000000000000000000000008d6",
-  "0x00000000000000000000000000000000000000000000000000000000000008d7",
-  "0x00000000000000000000000000000000000000000000000000000000000008d8",
-  "0x00000000000000000000000000000000000000000000000000000000000008d9",
-  "0x00000000000000000000000000000000000000000000000000000000000008da",
-  "0x00000000000000000000000000000000000000000000000000000000000008db",
-  "0x00000000000000000000000000000000000000000000000000000000000008dc",
-  "0x00000000000000000000000000000000000000000000000000000000000008dd",
-  "0x00000000000000000000000000000000000000000000000000000000000008de",
-  "0x00000000000000000000000000000000000000000000000000000000000008df",
-  "0x00000000000000000000000000000000000000000000000000000000000008e0",
-  "0x00000000000000000000000000000000000000000000000000000000000008e1",
-  "0x00000000000000000000000000000000000000000000000000000000000008e2",
-  "0x00000000000000000000000000000000000000000000000000000000000008e3",
-  "0x00000000000000000000000000000000000000000000000000000000000008e4",
-  "0x00000000000000000000000000000000000000000000000000000000000008e5",
-  "0x00000000000000000000000000000000000000000000000000000000000008e6",
-  "0x00000000000000000000000000000000000000000000000000000000000008e7",
-  "0x00000000000000000000000000000000000000000000000000000000000008e8",
-  "0x00000000000000000000000000000000000000000000000000000000000008e9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ea",
-  "0x00000000000000000000000000000000000000000000000000000000000008eb",
-  "0x00000000000000000000000000000000000000000000000000000000000008ec",
-  "0x00000000000000000000000000000000000000000000000000000000000008ed",
-  "0x00000000000000000000000000000000000000000000000000000000000008ee",
-  "0x00000000000000000000000000000000000000000000000000000000000008ef",
-  "0x00000000000000000000000000000000000000000000000000000000000008f0",
-  "0x00000000000000000000000000000000000000000000000000000000000008f1",
-  "0x00000000000000000000000000000000000000000000000000000000000008f2",
-  "0x00000000000000000000000000000000000000000000000000000000000008f3",
-  "0x00000000000000000000000000000000000000000000000000000000000008f4",
-  "0x00000000000000000000000000000000000000000000000000000000000008f5",
-  "0x00000000000000000000000000000000000000000000000000000000000008f6",
-  "0x00000000000000000000000000000000000000000000000000000000000008f7",
-  "0x00000000000000000000000000000000000000000000000000000000000008f8",
-  "0x00000000000000000000000000000000000000000000000000000000000008f9",
-  "0x00000000000000000000000000000000000000000000000000000000000008fa",
-  "0x00000000000000000000000000000000000000000000000000000000000008fb",
-  "0x00000000000000000000000000000000000000000000000000000000000008fc",
-  "0x00000000000000000000000000000000000000000000000000000000000008fd",
-  "0x00000000000000000000000000000000000000000000000000000000000008fe",
-  "0x00000000000000000000000000000000000000000000000000000000000008ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000900",
-  "0x0000000000000000000000000000000000000000000000000000000000000901",
-  "0x0000000000000000000000000000000000000000000000000000000000000902",
-  "0x0000000000000000000000000000000000000000000000000000000000000903",
-  "0x0000000000000000000000000000000000000000000000000000000000000904",
-  "0x0000000000000000000000000000000000000000000000000000000000000905",
-  "0x0000000000000000000000000000000000000000000000000000000000000906",
-  "0x0000000000000000000000000000000000000000000000000000000000000907",
-  "0x0000000000000000000000000000000000000000000000000000000000000908",
-  "0x0000000000000000000000000000000000000000000000000000000000000909",
-  "0x000000000000000000000000000000000000000000000000000000000000090a",
-  "0x000000000000000000000000000000000000000000000000000000000000090b",
-  "0x000000000000000000000000000000000000000000000000000000000000090c",
-  "0x000000000000000000000000000000000000000000000000000000000000090d",
-  "0x000000000000000000000000000000000000000000000000000000000000090e",
-  "0x000000000000000000000000000000000000000000000000000000000000090f",
-  "0x0000000000000000000000000000000000000000000000000000000000000910",
-  "0x0000000000000000000000000000000000000000000000000000000000000911",
-  "0x0000000000000000000000000000000000000000000000000000000000000912",
-  "0x0000000000000000000000000000000000000000000000000000000000000913",
-  "0x0000000000000000000000000000000000000000000000000000000000000914",
-  "0x0000000000000000000000000000000000000000000000000000000000000915",
-  "0x0000000000000000000000000000000000000000000000000000000000000916",
-  "0x0000000000000000000000000000000000000000000000000000000000000917",
-  "0x0000000000000000000000000000000000000000000000000000000000000918",
-  "0x0000000000000000000000000000000000000000000000000000000000000919",
-  "0x000000000000000000000000000000000000000000000000000000000000091a",
-  "0x000000000000000000000000000000000000000000000000000000000000091b",
-  "0x000000000000000000000000000000000000000000000000000000000000091c",
-  "0x000000000000000000000000000000000000000000000000000000000000091d",
-  "0x000000000000000000000000000000000000000000000000000000000000091e",
-  "0x000000000000000000000000000000000000000000000000000000000000091f",
-  "0x0000000000000000000000000000000000000000000000000000000000000920",
-  "0x0000000000000000000000000000000000000000000000000000000000000921",
-  "0x0000000000000000000000000000000000000000000000000000000000000922",
-  "0x0000000000000000000000000000000000000000000000000000000000000923",
-  "0x0000000000000000000000000000000000000000000000000000000000000924",
-  "0x0000000000000000000000000000000000000000000000000000000000000925",
-  "0x0000000000000000000000000000000000000000000000000000000000000926",
-  "0x0000000000000000000000000000000000000000000000000000000000000927",
-  "0x0000000000000000000000000000000000000000000000000000000000000928",
-  "0x0000000000000000000000000000000000000000000000000000000000000929",
-  "0x000000000000000000000000000000000000000000000000000000000000092a",
-  "0x000000000000000000000000000000000000000000000000000000000000092b",
-  "0x000000000000000000000000000000000000000000000000000000000000092c",
-  "0x000000000000000000000000000000000000000000000000000000000000092d",
-  "0x000000000000000000000000000000000000000000000000000000000000092e",
-  "0x000000000000000000000000000000000000000000000000000000000000092f",
-  "0x0000000000000000000000000000000000000000000000000000000000000930",
-  "0x0000000000000000000000000000000000000000000000000000000000000931",
-  "0x0000000000000000000000000000000000000000000000000000000000000932",
-  "0x0000000000000000000000000000000000000000000000000000000000000933",
-  "0x0000000000000000000000000000000000000000000000000000000000000934",
-  "0x0000000000000000000000000000000000000000000000000000000000000935",
-  "0x0000000000000000000000000000000000000000000000000000000000000936",
-  "0x0000000000000000000000000000000000000000000000000000000000000937",
-  "0x0000000000000000000000000000000000000000000000000000000000000938",
-  "0x0000000000000000000000000000000000000000000000000000000000000939",
-  "0x000000000000000000000000000000000000000000000000000000000000093a",
-  "0x000000000000000000000000000000000000000000000000000000000000093b",
-  "0x000000000000000000000000000000000000000000000000000000000000093c",
-  "0x000000000000000000000000000000000000000000000000000000000000093d",
-  "0x000000000000000000000000000000000000000000000000000000000000093e",
-  "0x000000000000000000000000000000000000000000000000000000000000093f",
-  "0x0000000000000000000000000000000000000000000000000000000000000940",
-  "0x0000000000000000000000000000000000000000000000000000000000000941",
-  "0x0000000000000000000000000000000000000000000000000000000000000942",
-  "0x0000000000000000000000000000000000000000000000000000000000000943",
-  "0x0000000000000000000000000000000000000000000000000000000000000944",
-  "0x0000000000000000000000000000000000000000000000000000000000000945",
-  "0x0000000000000000000000000000000000000000000000000000000000000946",
-  "0x0000000000000000000000000000000000000000000000000000000000000947",
-  "0x0000000000000000000000000000000000000000000000000000000000000948",
-  "0x0000000000000000000000000000000000000000000000000000000000000949",
-  "0x000000000000000000000000000000000000000000000000000000000000094a",
-  "0x000000000000000000000000000000000000000000000000000000000000094b",
-  "0x000000000000000000000000000000000000000000000000000000000000094c",
-  "0x000000000000000000000000000000000000000000000000000000000000094d",
-  "0x000000000000000000000000000000000000000000000000000000000000094e",
-  "0x000000000000000000000000000000000000000000000000000000000000094f",
-  "0x0000000000000000000000000000000000000000000000000000000000000950",
-  "0x0000000000000000000000000000000000000000000000000000000000000951",
-  "0x0000000000000000000000000000000000000000000000000000000000000952",
-  "0x0000000000000000000000000000000000000000000000000000000000000953",
-  "0x0000000000000000000000000000000000000000000000000000000000000954",
-  "0x0000000000000000000000000000000000000000000000000000000000000955",
-  "0x0000000000000000000000000000000000000000000000000000000000000956",
-  "0x0000000000000000000000000000000000000000000000000000000000000957",
-  "0x0000000000000000000000000000000000000000000000000000000000000958",
-  "0x0000000000000000000000000000000000000000000000000000000000000959",
-  "0x000000000000000000000000000000000000000000000000000000000000095a",
-  "0x000000000000000000000000000000000000000000000000000000000000095b",
-  "0x000000000000000000000000000000000000000000000000000000000000095c",
-  "0x000000000000000000000000000000000000000000000000000000000000095d",
-  "0x000000000000000000000000000000000000000000000000000000000000095e",
-  "0x000000000000000000000000000000000000000000000000000000000000095f",
-  "0x0000000000000000000000000000000000000000000000000000000000000960",
-  "0x0000000000000000000000000000000000000000000000000000000000000961",
-  "0x0000000000000000000000000000000000000000000000000000000000000962",
-  "0x0000000000000000000000000000000000000000000000000000000000000963",
-  "0x0000000000000000000000000000000000000000000000000000000000000964",
-  "0x0000000000000000000000000000000000000000000000000000000000000965",
-  "0x0000000000000000000000000000000000000000000000000000000000000966",
-  "0x0000000000000000000000000000000000000000000000000000000000000967",
-  "0x0000000000000000000000000000000000000000000000000000000000000968",
-  "0x0000000000000000000000000000000000000000000000000000000000000969",
-  "0x000000000000000000000000000000000000000000000000000000000000096a",
-  "0x000000000000000000000000000000000000000000000000000000000000096b",
-  "0x000000000000000000000000000000000000000000000000000000000000096c",
-  "0x000000000000000000000000000000000000000000000000000000000000096d",
-  "0x000000000000000000000000000000000000000000000000000000000000096e",
-  "0x000000000000000000000000000000000000000000000000000000000000096f",
-  "0x0000000000000000000000000000000000000000000000000000000000000970",
-  "0x0000000000000000000000000000000000000000000000000000000000000971",
-  "0x0000000000000000000000000000000000000000000000000000000000000972",
-  "0x0000000000000000000000000000000000000000000000000000000000000973",
-  "0x0000000000000000000000000000000000000000000000000000000000000974",
-  "0x0000000000000000000000000000000000000000000000000000000000000975",
-  "0x0000000000000000000000000000000000000000000000000000000000000976",
-  "0x0000000000000000000000000000000000000000000000000000000000000977",
-  "0x0000000000000000000000000000000000000000000000000000000000000978",
-  "0x0000000000000000000000000000000000000000000000000000000000000979",
-  "0x000000000000000000000000000000000000000000000000000000000000097a",
-  "0x000000000000000000000000000000000000000000000000000000000000097b",
-  "0x000000000000000000000000000000000000000000000000000000000000097c",
-  "0x000000000000000000000000000000000000000000000000000000000000097d",
-  "0x000000000000000000000000000000000000000000000000000000000000097e",
-  "0x000000000000000000000000000000000000000000000000000000000000097f",
-  "0x0000000000000000000000000000000000000000000000000000000000000980",
-  "0x0000000000000000000000000000000000000000000000000000000000000981",
-  "0x0000000000000000000000000000000000000000000000000000000000000982",
-  "0x0000000000000000000000000000000000000000000000000000000000000983",
-  "0x0000000000000000000000000000000000000000000000000000000000000984",
-  "0x0000000000000000000000000000000000000000000000000000000000000985",
-  "0x0000000000000000000000000000000000000000000000000000000000000986",
-  "0x0000000000000000000000000000000000000000000000000000000000000987",
-  "0x0000000000000000000000000000000000000000000000000000000000000988",
-  "0x0000000000000000000000000000000000000000000000000000000000000989",
-  "0x000000000000000000000000000000000000000000000000000000000000098a",
-  "0x000000000000000000000000000000000000000000000000000000000000098b",
-  "0x000000000000000000000000000000000000000000000000000000000000098c",
-  "0x000000000000000000000000000000000000000000000000000000000000098d",
-  "0x000000000000000000000000000000000000000000000000000000000000098e",
-  "0x000000000000000000000000000000000000000000000000000000000000098f",
-  "0x0000000000000000000000000000000000000000000000000000000000000990",
-  "0x0000000000000000000000000000000000000000000000000000000000000991",
-  "0x0000000000000000000000000000000000000000000000000000000000000992",
-  "0x0000000000000000000000000000000000000000000000000000000000000993",
-  "0x0000000000000000000000000000000000000000000000000000000000000994",
-  "0x0000000000000000000000000000000000000000000000000000000000000995",
-  "0x0000000000000000000000000000000000000000000000000000000000000996",
-  "0x0000000000000000000000000000000000000000000000000000000000000997",
-  "0x0000000000000000000000000000000000000000000000000000000000000998",
-  "0x0000000000000000000000000000000000000000000000000000000000000999",
-  "0x000000000000000000000000000000000000000000000000000000000000099a",
-  "0x000000000000000000000000000000000000000000000000000000000000099b",
-  "0x000000000000000000000000000000000000000000000000000000000000099c",
-  "0x000000000000000000000000000000000000000000000000000000000000099d",
-  "0x000000000000000000000000000000000000000000000000000000000000099e",
-  "0x000000000000000000000000000000000000000000000000000000000000099f",
-  "0x00000000000000000000000000000000000000000000000000000000000009a0",
-  "0x00000000000000000000000000000000000000000000000000000000000009a1",
-  "0x00000000000000000000000000000000000000000000000000000000000009a2",
-  "0x00000000000000000000000000000000000000000000000000000000000009a3",
-  "0x00000000000000000000000000000000000000000000000000000000000009a4",
-  "0x00000000000000000000000000000000000000000000000000000000000009a5",
-  "0x00000000000000000000000000000000000000000000000000000000000009a6",
-  "0x00000000000000000000000000000000000000000000000000000000000009a7",
-  "0x00000000000000000000000000000000000000000000000000000000000009a8",
-  "0x00000000000000000000000000000000000000000000000000000000000009a9",
-  "0x00000000000000000000000000000000000000000000000000000000000009aa",
-  "0x00000000000000000000000000000000000000000000000000000000000009ab",
-  "0x00000000000000000000000000000000000000000000000000000000000009ac",
-  "0x00000000000000000000000000000000000000000000000000000000000009ad",
-  "0x00000000000000000000000000000000000000000000000000000000000009ae",
-  "0x00000000000000000000000000000000000000000000000000000000000009af",
-  "0x00000000000000000000000000000000000000000000000000000000000009b0",
-  "0x00000000000000000000000000000000000000000000000000000000000009b1",
-  "0x00000000000000000000000000000000000000000000000000000000000009b2",
-  "0x00000000000000000000000000000000000000000000000000000000000009b3",
-  "0x00000000000000000000000000000000000000000000000000000000000009b4",
-  "0x00000000000000000000000000000000000000000000000000000000000009b5",
-  "0x00000000000000000000000000000000000000000000000000000000000009b6",
-  "0x00000000000000000000000000000000000000000000000000000000000009b7",
-  "0x00000000000000000000000000000000000000000000000000000000000009b8",
-  "0x00000000000000000000000000000000000000000000000000000000000009b9",
-  "0x00000000000000000000000000000000000000000000000000000000000009ba",
-  "0x00000000000000000000000000000000000000000000000000000000000009bb",
-  "0x00000000000000000000000000000000000000000000000000000000000009bc",
-  "0x00000000000000000000000000000000000000000000000000000000000009bd",
-  "0x00000000000000000000000000000000000000000000000000000000000009be",
-  "0x00000000000000000000000000000000000000000000000000000000000009bf",
-  "0x00000000000000000000000000000000000000000000000000000000000009c0",
-  "0x00000000000000000000000000000000000000000000000000000000000009c1",
-  "0x00000000000000000000000000000000000000000000000000000000000009c2",
-  "0x00000000000000000000000000000000000000000000000000000000000009c3",
-  "0x00000000000000000000000000000000000000000000000000000000000009c4",
-  "0x00000000000000000000000000000000000000000000000000000000000009c5",
-  "0x00000000000000000000000000000000000000000000000000000000000009c6",
-  "0x00000000000000000000000000000000000000000000000000000000000009c7",
-  "0x00000000000000000000000000000000000000000000000000000000000009c8",
-  "0x00000000000000000000000000000000000000000000000000000000000009c9",
-  "0x00000000000000000000000000000000000000000000000000000000000009ca",
-  "0x00000000000000000000000000000000000000000000000000000000000009cb",
-  "0x00000000000000000000000000000000000000000000000000000000000009cc",
-  "0x00000000000000000000000000000000000000000000000000000000000009cd",
-  "0x00000000000000000000000000000000000000000000000000000000000009ce",
-  "0x00000000000000000000000000000000000000000000000000000000000009cf",
-  "0x00000000000000000000000000000000000000000000000000000000000009d0",
-  "0x00000000000000000000000000000000000000000000000000000000000009d1",
-  "0x00000000000000000000000000000000000000000000000000000000000009d2",
-  "0x00000000000000000000000000000000000000000000000000000000000009d3",
-  "0x00000000000000000000000000000000000000000000000000000000000009d4",
-  "0x00000000000000000000000000000000000000000000000000000000000009d5",
-  "0x00000000000000000000000000000000000000000000000000000000000009d6",
-  "0x00000000000000000000000000000000000000000000000000000000000009d7",
-  "0x00000000000000000000000000000000000000000000000000000000000009d8",
-  "0x00000000000000000000000000000000000000000000000000000000000009d9",
-  "0x00000000000000000000000000000000000000000000000000000000000009da",
-  "0x00000000000000000000000000000000000000000000000000000000000009db"
+  "0x00000000000000000000000000000000000000000000000000000000000006db"
 ]
-  num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400"
-  num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400"
+  num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000100"
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml
index 00d469d40a2b..2421327cd0ce 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml
@@ -1,15 +1,15 @@
 [inputs]
 l1_to_l2_message_frontier_hint = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb",
+  "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d",
+  "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037",
+  "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da",
+  "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249",
+  "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f",
+  "0x221cf368938c74e4fced9dfb2a8e37cd8a6c57d21385c249f0b5c2412341287f",
+  "0x2c5214dfc4d70d2619fce2a7e02ddcf380576dca42b66c9215c7d8d1ec154116",
+  "0x13abc9bba431e6930c169f5daeb60aedbb27d7618c7ff88b3b4ec1c6de1d6bb8",
   "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f",
   "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad",
   "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da",
@@ -561,7 +561,7 @@ new_archive_sibling_path = [
     accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0"
 
       [inputs.previous_rollup.public_inputs.constants]
-      vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c"
+      vk_tree_root = "0x1d366660277d0da1e9c56a961b6d5b5cac2b74641eba14de96aff4f319db5556"
       protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b"
       prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
@@ -570,8 +570,8 @@ new_archive_sibling_path = [
         next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001"
 
         [inputs.previous_rollup.public_inputs.constants.l1_to_l2_tree_snapshot]
-        root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+        root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
         [inputs.previous_rollup.public_inputs.constants.global_variables]
         chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
@@ -642,10 +642,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b7d1b44c"
 ]
         state = [
-  "0x152c3ca571fdac98b841ce024a71e95386cf9e12fc75f332e758ec2bbb8abedd",
-  "0x2b95018fadbe3202af295aba0c2c9bee5fbf974c125ad1df07aac938788075f1",
-  "0x23f43785270be64381f8aed6a97343880dd65c46edee94cc788f7b233a775aac",
-  "0x27a409da6f771f48f0170b366f7a66e88ef0416365e20c3d573969923a724b98"
+  "0x0de173f5532118eb59526bae8af68e3305e49e824124773816380e33e2310cf6",
+  "0x216a64f31a5cb6286fb80b82b319ed83db74f85b0a63343162a4096ba95fd620",
+  "0x04c21ae0ddc66d648cb47b245327085b045231fe7f0bac9fd4ddb67471086b53",
+  "0x20d77214060a7bf8d08f9bfce1fa6fe6cacad506185077ec3191a1ec52dbce40"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002"
         squeeze_mode = false
@@ -656,10 +656,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x1fc39d0a428c8536dbca551ea79848acf67d89d090fd8c643c7d90f2e8f32340",
   "0x12ce5a49a1ceca53ada7bee003f929bbd65abaa74e8072a81f304c2c96c44e31",
   "0x2dd71474f7775d87b6c2986ace5f654686583f0970d7400b1ccf8096dad131b5",
-  "0x0aca02f69b05a42958d30ced7da19a9e135e0c83b75e72ae5f7e2bec714a418f",
+  "0x22fe3deda3c756121ae860fd950eef8dc76c6e4db472e345da469025560db9d8",
   "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d",
   "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41",
-  "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd"
+  "0x0a082458fe660d17b7c5348e39012f798c9805cc616347c76862995fb24394e9"
 ]
 
       [inputs.previous_rollup.vk_data.vk]
@@ -1039,778 +1039,9 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000000006d8",
   "0x00000000000000000000000000000000000000000000000000000000000006d9",
   "0x00000000000000000000000000000000000000000000000000000000000006da",
-  "0x00000000000000000000000000000000000000000000000000000000000006db",
-  "0x00000000000000000000000000000000000000000000000000000000000006dc",
-  "0x00000000000000000000000000000000000000000000000000000000000006dd",
-  "0x00000000000000000000000000000000000000000000000000000000000006de",
-  "0x00000000000000000000000000000000000000000000000000000000000006df",
-  "0x00000000000000000000000000000000000000000000000000000000000006e0",
-  "0x00000000000000000000000000000000000000000000000000000000000006e1",
-  "0x00000000000000000000000000000000000000000000000000000000000006e2",
-  "0x00000000000000000000000000000000000000000000000000000000000006e3",
-  "0x00000000000000000000000000000000000000000000000000000000000006e4",
-  "0x00000000000000000000000000000000000000000000000000000000000006e5",
-  "0x00000000000000000000000000000000000000000000000000000000000006e6",
-  "0x00000000000000000000000000000000000000000000000000000000000006e7",
-  "0x00000000000000000000000000000000000000000000000000000000000006e8",
-  "0x00000000000000000000000000000000000000000000000000000000000006e9",
-  "0x00000000000000000000000000000000000000000000000000000000000006ea",
-  "0x00000000000000000000000000000000000000000000000000000000000006eb",
-  "0x00000000000000000000000000000000000000000000000000000000000006ec",
-  "0x00000000000000000000000000000000000000000000000000000000000006ed",
-  "0x00000000000000000000000000000000000000000000000000000000000006ee",
-  "0x00000000000000000000000000000000000000000000000000000000000006ef",
-  "0x00000000000000000000000000000000000000000000000000000000000006f0",
-  "0x00000000000000000000000000000000000000000000000000000000000006f1",
-  "0x00000000000000000000000000000000000000000000000000000000000006f2",
-  "0x00000000000000000000000000000000000000000000000000000000000006f3",
-  "0x00000000000000000000000000000000000000000000000000000000000006f4",
-  "0x00000000000000000000000000000000000000000000000000000000000006f5",
-  "0x00000000000000000000000000000000000000000000000000000000000006f6",
-  "0x00000000000000000000000000000000000000000000000000000000000006f7",
-  "0x00000000000000000000000000000000000000000000000000000000000006f8",
-  "0x00000000000000000000000000000000000000000000000000000000000006f9",
-  "0x00000000000000000000000000000000000000000000000000000000000006fa",
-  "0x00000000000000000000000000000000000000000000000000000000000006fb",
-  "0x00000000000000000000000000000000000000000000000000000000000006fc",
-  "0x00000000000000000000000000000000000000000000000000000000000006fd",
-  "0x00000000000000000000000000000000000000000000000000000000000006fe",
-  "0x00000000000000000000000000000000000000000000000000000000000006ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000700",
-  "0x0000000000000000000000000000000000000000000000000000000000000701",
-  "0x0000000000000000000000000000000000000000000000000000000000000702",
-  "0x0000000000000000000000000000000000000000000000000000000000000703",
-  "0x0000000000000000000000000000000000000000000000000000000000000704",
-  "0x0000000000000000000000000000000000000000000000000000000000000705",
-  "0x0000000000000000000000000000000000000000000000000000000000000706",
-  "0x0000000000000000000000000000000000000000000000000000000000000707",
-  "0x0000000000000000000000000000000000000000000000000000000000000708",
-  "0x0000000000000000000000000000000000000000000000000000000000000709",
-  "0x000000000000000000000000000000000000000000000000000000000000070a",
-  "0x000000000000000000000000000000000000000000000000000000000000070b",
-  "0x000000000000000000000000000000000000000000000000000000000000070c",
-  "0x000000000000000000000000000000000000000000000000000000000000070d",
-  "0x000000000000000000000000000000000000000000000000000000000000070e",
-  "0x000000000000000000000000000000000000000000000000000000000000070f",
-  "0x0000000000000000000000000000000000000000000000000000000000000710",
-  "0x0000000000000000000000000000000000000000000000000000000000000711",
-  "0x0000000000000000000000000000000000000000000000000000000000000712",
-  "0x0000000000000000000000000000000000000000000000000000000000000713",
-  "0x0000000000000000000000000000000000000000000000000000000000000714",
-  "0x0000000000000000000000000000000000000000000000000000000000000715",
-  "0x0000000000000000000000000000000000000000000000000000000000000716",
-  "0x0000000000000000000000000000000000000000000000000000000000000717",
-  "0x0000000000000000000000000000000000000000000000000000000000000718",
-  "0x0000000000000000000000000000000000000000000000000000000000000719",
-  "0x000000000000000000000000000000000000000000000000000000000000071a",
-  "0x000000000000000000000000000000000000000000000000000000000000071b",
-  "0x000000000000000000000000000000000000000000000000000000000000071c",
-  "0x000000000000000000000000000000000000000000000000000000000000071d",
-  "0x000000000000000000000000000000000000000000000000000000000000071e",
-  "0x000000000000000000000000000000000000000000000000000000000000071f",
-  "0x0000000000000000000000000000000000000000000000000000000000000720",
-  "0x0000000000000000000000000000000000000000000000000000000000000721",
-  "0x0000000000000000000000000000000000000000000000000000000000000722",
-  "0x0000000000000000000000000000000000000000000000000000000000000723",
-  "0x0000000000000000000000000000000000000000000000000000000000000724",
-  "0x0000000000000000000000000000000000000000000000000000000000000725",
-  "0x0000000000000000000000000000000000000000000000000000000000000726",
-  "0x0000000000000000000000000000000000000000000000000000000000000727",
-  "0x0000000000000000000000000000000000000000000000000000000000000728",
-  "0x0000000000000000000000000000000000000000000000000000000000000729",
-  "0x000000000000000000000000000000000000000000000000000000000000072a",
-  "0x000000000000000000000000000000000000000000000000000000000000072b",
-  "0x000000000000000000000000000000000000000000000000000000000000072c",
-  "0x000000000000000000000000000000000000000000000000000000000000072d",
-  "0x000000000000000000000000000000000000000000000000000000000000072e",
-  "0x000000000000000000000000000000000000000000000000000000000000072f",
-  "0x0000000000000000000000000000000000000000000000000000000000000730",
-  "0x0000000000000000000000000000000000000000000000000000000000000731",
-  "0x0000000000000000000000000000000000000000000000000000000000000732",
-  "0x0000000000000000000000000000000000000000000000000000000000000733",
-  "0x0000000000000000000000000000000000000000000000000000000000000734",
-  "0x0000000000000000000000000000000000000000000000000000000000000735",
-  "0x0000000000000000000000000000000000000000000000000000000000000736",
-  "0x0000000000000000000000000000000000000000000000000000000000000737",
-  "0x0000000000000000000000000000000000000000000000000000000000000738",
-  "0x0000000000000000000000000000000000000000000000000000000000000739",
-  "0x000000000000000000000000000000000000000000000000000000000000073a",
-  "0x000000000000000000000000000000000000000000000000000000000000073b",
-  "0x000000000000000000000000000000000000000000000000000000000000073c",
-  "0x000000000000000000000000000000000000000000000000000000000000073d",
-  "0x000000000000000000000000000000000000000000000000000000000000073e",
-  "0x000000000000000000000000000000000000000000000000000000000000073f",
-  "0x0000000000000000000000000000000000000000000000000000000000000740",
-  "0x0000000000000000000000000000000000000000000000000000000000000741",
-  "0x0000000000000000000000000000000000000000000000000000000000000742",
-  "0x0000000000000000000000000000000000000000000000000000000000000743",
-  "0x0000000000000000000000000000000000000000000000000000000000000744",
-  "0x0000000000000000000000000000000000000000000000000000000000000745",
-  "0x0000000000000000000000000000000000000000000000000000000000000746",
-  "0x0000000000000000000000000000000000000000000000000000000000000747",
-  "0x0000000000000000000000000000000000000000000000000000000000000748",
-  "0x0000000000000000000000000000000000000000000000000000000000000749",
-  "0x000000000000000000000000000000000000000000000000000000000000074a",
-  "0x000000000000000000000000000000000000000000000000000000000000074b",
-  "0x000000000000000000000000000000000000000000000000000000000000074c",
-  "0x000000000000000000000000000000000000000000000000000000000000074d",
-  "0x000000000000000000000000000000000000000000000000000000000000074e",
-  "0x000000000000000000000000000000000000000000000000000000000000074f",
-  "0x0000000000000000000000000000000000000000000000000000000000000750",
-  "0x0000000000000000000000000000000000000000000000000000000000000751",
-  "0x0000000000000000000000000000000000000000000000000000000000000752",
-  "0x0000000000000000000000000000000000000000000000000000000000000753",
-  "0x0000000000000000000000000000000000000000000000000000000000000754",
-  "0x0000000000000000000000000000000000000000000000000000000000000755",
-  "0x0000000000000000000000000000000000000000000000000000000000000756",
-  "0x0000000000000000000000000000000000000000000000000000000000000757",
-  "0x0000000000000000000000000000000000000000000000000000000000000758",
-  "0x0000000000000000000000000000000000000000000000000000000000000759",
-  "0x000000000000000000000000000000000000000000000000000000000000075a",
-  "0x000000000000000000000000000000000000000000000000000000000000075b",
-  "0x000000000000000000000000000000000000000000000000000000000000075c",
-  "0x000000000000000000000000000000000000000000000000000000000000075d",
-  "0x000000000000000000000000000000000000000000000000000000000000075e",
-  "0x000000000000000000000000000000000000000000000000000000000000075f",
-  "0x0000000000000000000000000000000000000000000000000000000000000760",
-  "0x0000000000000000000000000000000000000000000000000000000000000761",
-  "0x0000000000000000000000000000000000000000000000000000000000000762",
-  "0x0000000000000000000000000000000000000000000000000000000000000763",
-  "0x0000000000000000000000000000000000000000000000000000000000000764",
-  "0x0000000000000000000000000000000000000000000000000000000000000765",
-  "0x0000000000000000000000000000000000000000000000000000000000000766",
-  "0x0000000000000000000000000000000000000000000000000000000000000767",
-  "0x0000000000000000000000000000000000000000000000000000000000000768",
-  "0x0000000000000000000000000000000000000000000000000000000000000769",
-  "0x000000000000000000000000000000000000000000000000000000000000076a",
-  "0x000000000000000000000000000000000000000000000000000000000000076b",
-  "0x000000000000000000000000000000000000000000000000000000000000076c",
-  "0x000000000000000000000000000000000000000000000000000000000000076d",
-  "0x000000000000000000000000000000000000000000000000000000000000076e",
-  "0x000000000000000000000000000000000000000000000000000000000000076f",
-  "0x0000000000000000000000000000000000000000000000000000000000000770",
-  "0x0000000000000000000000000000000000000000000000000000000000000771",
-  "0x0000000000000000000000000000000000000000000000000000000000000772",
-  "0x0000000000000000000000000000000000000000000000000000000000000773",
-  "0x0000000000000000000000000000000000000000000000000000000000000774",
-  "0x0000000000000000000000000000000000000000000000000000000000000775",
-  "0x0000000000000000000000000000000000000000000000000000000000000776",
-  "0x0000000000000000000000000000000000000000000000000000000000000777",
-  "0x0000000000000000000000000000000000000000000000000000000000000778",
-  "0x0000000000000000000000000000000000000000000000000000000000000779",
-  "0x000000000000000000000000000000000000000000000000000000000000077a",
-  "0x000000000000000000000000000000000000000000000000000000000000077b",
-  "0x000000000000000000000000000000000000000000000000000000000000077c",
-  "0x000000000000000000000000000000000000000000000000000000000000077d",
-  "0x000000000000000000000000000000000000000000000000000000000000077e",
-  "0x000000000000000000000000000000000000000000000000000000000000077f",
-  "0x0000000000000000000000000000000000000000000000000000000000000780",
-  "0x0000000000000000000000000000000000000000000000000000000000000781",
-  "0x0000000000000000000000000000000000000000000000000000000000000782",
-  "0x0000000000000000000000000000000000000000000000000000000000000783",
-  "0x0000000000000000000000000000000000000000000000000000000000000784",
-  "0x0000000000000000000000000000000000000000000000000000000000000785",
-  "0x0000000000000000000000000000000000000000000000000000000000000786",
-  "0x0000000000000000000000000000000000000000000000000000000000000787",
-  "0x0000000000000000000000000000000000000000000000000000000000000788",
-  "0x0000000000000000000000000000000000000000000000000000000000000789",
-  "0x000000000000000000000000000000000000000000000000000000000000078a",
-  "0x000000000000000000000000000000000000000000000000000000000000078b",
-  "0x000000000000000000000000000000000000000000000000000000000000078c",
-  "0x000000000000000000000000000000000000000000000000000000000000078d",
-  "0x000000000000000000000000000000000000000000000000000000000000078e",
-  "0x000000000000000000000000000000000000000000000000000000000000078f",
-  "0x0000000000000000000000000000000000000000000000000000000000000790",
-  "0x0000000000000000000000000000000000000000000000000000000000000791",
-  "0x0000000000000000000000000000000000000000000000000000000000000792",
-  "0x0000000000000000000000000000000000000000000000000000000000000793",
-  "0x0000000000000000000000000000000000000000000000000000000000000794",
-  "0x0000000000000000000000000000000000000000000000000000000000000795",
-  "0x0000000000000000000000000000000000000000000000000000000000000796",
-  "0x0000000000000000000000000000000000000000000000000000000000000797",
-  "0x0000000000000000000000000000000000000000000000000000000000000798",
-  "0x0000000000000000000000000000000000000000000000000000000000000799",
-  "0x000000000000000000000000000000000000000000000000000000000000079a",
-  "0x000000000000000000000000000000000000000000000000000000000000079b",
-  "0x000000000000000000000000000000000000000000000000000000000000079c",
-  "0x000000000000000000000000000000000000000000000000000000000000079d",
-  "0x000000000000000000000000000000000000000000000000000000000000079e",
-  "0x000000000000000000000000000000000000000000000000000000000000079f",
-  "0x00000000000000000000000000000000000000000000000000000000000007a0",
-  "0x00000000000000000000000000000000000000000000000000000000000007a1",
-  "0x00000000000000000000000000000000000000000000000000000000000007a2",
-  "0x00000000000000000000000000000000000000000000000000000000000007a3",
-  "0x00000000000000000000000000000000000000000000000000000000000007a4",
-  "0x00000000000000000000000000000000000000000000000000000000000007a5",
-  "0x00000000000000000000000000000000000000000000000000000000000007a6",
-  "0x00000000000000000000000000000000000000000000000000000000000007a7",
-  "0x00000000000000000000000000000000000000000000000000000000000007a8",
-  "0x00000000000000000000000000000000000000000000000000000000000007a9",
-  "0x00000000000000000000000000000000000000000000000000000000000007aa",
-  "0x00000000000000000000000000000000000000000000000000000000000007ab",
-  "0x00000000000000000000000000000000000000000000000000000000000007ac",
-  "0x00000000000000000000000000000000000000000000000000000000000007ad",
-  "0x00000000000000000000000000000000000000000000000000000000000007ae",
-  "0x00000000000000000000000000000000000000000000000000000000000007af",
-  "0x00000000000000000000000000000000000000000000000000000000000007b0",
-  "0x00000000000000000000000000000000000000000000000000000000000007b1",
-  "0x00000000000000000000000000000000000000000000000000000000000007b2",
-  "0x00000000000000000000000000000000000000000000000000000000000007b3",
-  "0x00000000000000000000000000000000000000000000000000000000000007b4",
-  "0x00000000000000000000000000000000000000000000000000000000000007b5",
-  "0x00000000000000000000000000000000000000000000000000000000000007b6",
-  "0x00000000000000000000000000000000000000000000000000000000000007b7",
-  "0x00000000000000000000000000000000000000000000000000000000000007b8",
-  "0x00000000000000000000000000000000000000000000000000000000000007b9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ba",
-  "0x00000000000000000000000000000000000000000000000000000000000007bb",
-  "0x00000000000000000000000000000000000000000000000000000000000007bc",
-  "0x00000000000000000000000000000000000000000000000000000000000007bd",
-  "0x00000000000000000000000000000000000000000000000000000000000007be",
-  "0x00000000000000000000000000000000000000000000000000000000000007bf",
-  "0x00000000000000000000000000000000000000000000000000000000000007c0",
-  "0x00000000000000000000000000000000000000000000000000000000000007c1",
-  "0x00000000000000000000000000000000000000000000000000000000000007c2",
-  "0x00000000000000000000000000000000000000000000000000000000000007c3",
-  "0x00000000000000000000000000000000000000000000000000000000000007c4",
-  "0x00000000000000000000000000000000000000000000000000000000000007c5",
-  "0x00000000000000000000000000000000000000000000000000000000000007c6",
-  "0x00000000000000000000000000000000000000000000000000000000000007c7",
-  "0x00000000000000000000000000000000000000000000000000000000000007c8",
-  "0x00000000000000000000000000000000000000000000000000000000000007c9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ca",
-  "0x00000000000000000000000000000000000000000000000000000000000007cb",
-  "0x00000000000000000000000000000000000000000000000000000000000007cc",
-  "0x00000000000000000000000000000000000000000000000000000000000007cd",
-  "0x00000000000000000000000000000000000000000000000000000000000007ce",
-  "0x00000000000000000000000000000000000000000000000000000000000007cf",
-  "0x00000000000000000000000000000000000000000000000000000000000007d0",
-  "0x00000000000000000000000000000000000000000000000000000000000007d1",
-  "0x00000000000000000000000000000000000000000000000000000000000007d2",
-  "0x00000000000000000000000000000000000000000000000000000000000007d3",
-  "0x00000000000000000000000000000000000000000000000000000000000007d4",
-  "0x00000000000000000000000000000000000000000000000000000000000007d5",
-  "0x00000000000000000000000000000000000000000000000000000000000007d6",
-  "0x00000000000000000000000000000000000000000000000000000000000007d7",
-  "0x00000000000000000000000000000000000000000000000000000000000007d8",
-  "0x00000000000000000000000000000000000000000000000000000000000007d9",
-  "0x00000000000000000000000000000000000000000000000000000000000007da",
-  "0x00000000000000000000000000000000000000000000000000000000000007db",
-  "0x00000000000000000000000000000000000000000000000000000000000007dc",
-  "0x00000000000000000000000000000000000000000000000000000000000007dd",
-  "0x00000000000000000000000000000000000000000000000000000000000007de",
-  "0x00000000000000000000000000000000000000000000000000000000000007df",
-  "0x00000000000000000000000000000000000000000000000000000000000007e0",
-  "0x00000000000000000000000000000000000000000000000000000000000007e1",
-  "0x00000000000000000000000000000000000000000000000000000000000007e2",
-  "0x00000000000000000000000000000000000000000000000000000000000007e3",
-  "0x00000000000000000000000000000000000000000000000000000000000007e4",
-  "0x00000000000000000000000000000000000000000000000000000000000007e5",
-  "0x00000000000000000000000000000000000000000000000000000000000007e6",
-  "0x00000000000000000000000000000000000000000000000000000000000007e7",
-  "0x00000000000000000000000000000000000000000000000000000000000007e8",
-  "0x00000000000000000000000000000000000000000000000000000000000007e9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ea",
-  "0x00000000000000000000000000000000000000000000000000000000000007eb",
-  "0x00000000000000000000000000000000000000000000000000000000000007ec",
-  "0x00000000000000000000000000000000000000000000000000000000000007ed",
-  "0x00000000000000000000000000000000000000000000000000000000000007ee",
-  "0x00000000000000000000000000000000000000000000000000000000000007ef",
-  "0x00000000000000000000000000000000000000000000000000000000000007f0",
-  "0x00000000000000000000000000000000000000000000000000000000000007f1",
-  "0x00000000000000000000000000000000000000000000000000000000000007f2",
-  "0x00000000000000000000000000000000000000000000000000000000000007f3",
-  "0x00000000000000000000000000000000000000000000000000000000000007f4",
-  "0x00000000000000000000000000000000000000000000000000000000000007f5",
-  "0x00000000000000000000000000000000000000000000000000000000000007f6",
-  "0x00000000000000000000000000000000000000000000000000000000000007f7",
-  "0x00000000000000000000000000000000000000000000000000000000000007f8",
-  "0x00000000000000000000000000000000000000000000000000000000000007f9",
-  "0x00000000000000000000000000000000000000000000000000000000000007fa",
-  "0x00000000000000000000000000000000000000000000000000000000000007fb",
-  "0x00000000000000000000000000000000000000000000000000000000000007fc",
-  "0x00000000000000000000000000000000000000000000000000000000000007fd",
-  "0x00000000000000000000000000000000000000000000000000000000000007fe",
-  "0x00000000000000000000000000000000000000000000000000000000000007ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000800",
-  "0x0000000000000000000000000000000000000000000000000000000000000801",
-  "0x0000000000000000000000000000000000000000000000000000000000000802",
-  "0x0000000000000000000000000000000000000000000000000000000000000803",
-  "0x0000000000000000000000000000000000000000000000000000000000000804",
-  "0x0000000000000000000000000000000000000000000000000000000000000805",
-  "0x0000000000000000000000000000000000000000000000000000000000000806",
-  "0x0000000000000000000000000000000000000000000000000000000000000807",
-  "0x0000000000000000000000000000000000000000000000000000000000000808",
-  "0x0000000000000000000000000000000000000000000000000000000000000809",
-  "0x000000000000000000000000000000000000000000000000000000000000080a",
-  "0x000000000000000000000000000000000000000000000000000000000000080b",
-  "0x000000000000000000000000000000000000000000000000000000000000080c",
-  "0x000000000000000000000000000000000000000000000000000000000000080d",
-  "0x000000000000000000000000000000000000000000000000000000000000080e",
-  "0x000000000000000000000000000000000000000000000000000000000000080f",
-  "0x0000000000000000000000000000000000000000000000000000000000000810",
-  "0x0000000000000000000000000000000000000000000000000000000000000811",
-  "0x0000000000000000000000000000000000000000000000000000000000000812",
-  "0x0000000000000000000000000000000000000000000000000000000000000813",
-  "0x0000000000000000000000000000000000000000000000000000000000000814",
-  "0x0000000000000000000000000000000000000000000000000000000000000815",
-  "0x0000000000000000000000000000000000000000000000000000000000000816",
-  "0x0000000000000000000000000000000000000000000000000000000000000817",
-  "0x0000000000000000000000000000000000000000000000000000000000000818",
-  "0x0000000000000000000000000000000000000000000000000000000000000819",
-  "0x000000000000000000000000000000000000000000000000000000000000081a",
-  "0x000000000000000000000000000000000000000000000000000000000000081b",
-  "0x000000000000000000000000000000000000000000000000000000000000081c",
-  "0x000000000000000000000000000000000000000000000000000000000000081d",
-  "0x000000000000000000000000000000000000000000000000000000000000081e",
-  "0x000000000000000000000000000000000000000000000000000000000000081f",
-  "0x0000000000000000000000000000000000000000000000000000000000000820",
-  "0x0000000000000000000000000000000000000000000000000000000000000821",
-  "0x0000000000000000000000000000000000000000000000000000000000000822",
-  "0x0000000000000000000000000000000000000000000000000000000000000823",
-  "0x0000000000000000000000000000000000000000000000000000000000000824",
-  "0x0000000000000000000000000000000000000000000000000000000000000825",
-  "0x0000000000000000000000000000000000000000000000000000000000000826",
-  "0x0000000000000000000000000000000000000000000000000000000000000827",
-  "0x0000000000000000000000000000000000000000000000000000000000000828",
-  "0x0000000000000000000000000000000000000000000000000000000000000829",
-  "0x000000000000000000000000000000000000000000000000000000000000082a",
-  "0x000000000000000000000000000000000000000000000000000000000000082b",
-  "0x000000000000000000000000000000000000000000000000000000000000082c",
-  "0x000000000000000000000000000000000000000000000000000000000000082d",
-  "0x000000000000000000000000000000000000000000000000000000000000082e",
-  "0x000000000000000000000000000000000000000000000000000000000000082f",
-  "0x0000000000000000000000000000000000000000000000000000000000000830",
-  "0x0000000000000000000000000000000000000000000000000000000000000831",
-  "0x0000000000000000000000000000000000000000000000000000000000000832",
-  "0x0000000000000000000000000000000000000000000000000000000000000833",
-  "0x0000000000000000000000000000000000000000000000000000000000000834",
-  "0x0000000000000000000000000000000000000000000000000000000000000835",
-  "0x0000000000000000000000000000000000000000000000000000000000000836",
-  "0x0000000000000000000000000000000000000000000000000000000000000837",
-  "0x0000000000000000000000000000000000000000000000000000000000000838",
-  "0x0000000000000000000000000000000000000000000000000000000000000839",
-  "0x000000000000000000000000000000000000000000000000000000000000083a",
-  "0x000000000000000000000000000000000000000000000000000000000000083b",
-  "0x000000000000000000000000000000000000000000000000000000000000083c",
-  "0x000000000000000000000000000000000000000000000000000000000000083d",
-  "0x000000000000000000000000000000000000000000000000000000000000083e",
-  "0x000000000000000000000000000000000000000000000000000000000000083f",
-  "0x0000000000000000000000000000000000000000000000000000000000000840",
-  "0x0000000000000000000000000000000000000000000000000000000000000841",
-  "0x0000000000000000000000000000000000000000000000000000000000000842",
-  "0x0000000000000000000000000000000000000000000000000000000000000843",
-  "0x0000000000000000000000000000000000000000000000000000000000000844",
-  "0x0000000000000000000000000000000000000000000000000000000000000845",
-  "0x0000000000000000000000000000000000000000000000000000000000000846",
-  "0x0000000000000000000000000000000000000000000000000000000000000847",
-  "0x0000000000000000000000000000000000000000000000000000000000000848",
-  "0x0000000000000000000000000000000000000000000000000000000000000849",
-  "0x000000000000000000000000000000000000000000000000000000000000084a",
-  "0x000000000000000000000000000000000000000000000000000000000000084b",
-  "0x000000000000000000000000000000000000000000000000000000000000084c",
-  "0x000000000000000000000000000000000000000000000000000000000000084d",
-  "0x000000000000000000000000000000000000000000000000000000000000084e",
-  "0x000000000000000000000000000000000000000000000000000000000000084f",
-  "0x0000000000000000000000000000000000000000000000000000000000000850",
-  "0x0000000000000000000000000000000000000000000000000000000000000851",
-  "0x0000000000000000000000000000000000000000000000000000000000000852",
-  "0x0000000000000000000000000000000000000000000000000000000000000853",
-  "0x0000000000000000000000000000000000000000000000000000000000000854",
-  "0x0000000000000000000000000000000000000000000000000000000000000855",
-  "0x0000000000000000000000000000000000000000000000000000000000000856",
-  "0x0000000000000000000000000000000000000000000000000000000000000857",
-  "0x0000000000000000000000000000000000000000000000000000000000000858",
-  "0x0000000000000000000000000000000000000000000000000000000000000859",
-  "0x000000000000000000000000000000000000000000000000000000000000085a",
-  "0x000000000000000000000000000000000000000000000000000000000000085b",
-  "0x000000000000000000000000000000000000000000000000000000000000085c",
-  "0x000000000000000000000000000000000000000000000000000000000000085d",
-  "0x000000000000000000000000000000000000000000000000000000000000085e",
-  "0x000000000000000000000000000000000000000000000000000000000000085f",
-  "0x0000000000000000000000000000000000000000000000000000000000000860",
-  "0x0000000000000000000000000000000000000000000000000000000000000861",
-  "0x0000000000000000000000000000000000000000000000000000000000000862",
-  "0x0000000000000000000000000000000000000000000000000000000000000863",
-  "0x0000000000000000000000000000000000000000000000000000000000000864",
-  "0x0000000000000000000000000000000000000000000000000000000000000865",
-  "0x0000000000000000000000000000000000000000000000000000000000000866",
-  "0x0000000000000000000000000000000000000000000000000000000000000867",
-  "0x0000000000000000000000000000000000000000000000000000000000000868",
-  "0x0000000000000000000000000000000000000000000000000000000000000869",
-  "0x000000000000000000000000000000000000000000000000000000000000086a",
-  "0x000000000000000000000000000000000000000000000000000000000000086b",
-  "0x000000000000000000000000000000000000000000000000000000000000086c",
-  "0x000000000000000000000000000000000000000000000000000000000000086d",
-  "0x000000000000000000000000000000000000000000000000000000000000086e",
-  "0x000000000000000000000000000000000000000000000000000000000000086f",
-  "0x0000000000000000000000000000000000000000000000000000000000000870",
-  "0x0000000000000000000000000000000000000000000000000000000000000871",
-  "0x0000000000000000000000000000000000000000000000000000000000000872",
-  "0x0000000000000000000000000000000000000000000000000000000000000873",
-  "0x0000000000000000000000000000000000000000000000000000000000000874",
-  "0x0000000000000000000000000000000000000000000000000000000000000875",
-  "0x0000000000000000000000000000000000000000000000000000000000000876",
-  "0x0000000000000000000000000000000000000000000000000000000000000877",
-  "0x0000000000000000000000000000000000000000000000000000000000000878",
-  "0x0000000000000000000000000000000000000000000000000000000000000879",
-  "0x000000000000000000000000000000000000000000000000000000000000087a",
-  "0x000000000000000000000000000000000000000000000000000000000000087b",
-  "0x000000000000000000000000000000000000000000000000000000000000087c",
-  "0x000000000000000000000000000000000000000000000000000000000000087d",
-  "0x000000000000000000000000000000000000000000000000000000000000087e",
-  "0x000000000000000000000000000000000000000000000000000000000000087f",
-  "0x0000000000000000000000000000000000000000000000000000000000000880",
-  "0x0000000000000000000000000000000000000000000000000000000000000881",
-  "0x0000000000000000000000000000000000000000000000000000000000000882",
-  "0x0000000000000000000000000000000000000000000000000000000000000883",
-  "0x0000000000000000000000000000000000000000000000000000000000000884",
-  "0x0000000000000000000000000000000000000000000000000000000000000885",
-  "0x0000000000000000000000000000000000000000000000000000000000000886",
-  "0x0000000000000000000000000000000000000000000000000000000000000887",
-  "0x0000000000000000000000000000000000000000000000000000000000000888",
-  "0x0000000000000000000000000000000000000000000000000000000000000889",
-  "0x000000000000000000000000000000000000000000000000000000000000088a",
-  "0x000000000000000000000000000000000000000000000000000000000000088b",
-  "0x000000000000000000000000000000000000000000000000000000000000088c",
-  "0x000000000000000000000000000000000000000000000000000000000000088d",
-  "0x000000000000000000000000000000000000000000000000000000000000088e",
-  "0x000000000000000000000000000000000000000000000000000000000000088f",
-  "0x0000000000000000000000000000000000000000000000000000000000000890",
-  "0x0000000000000000000000000000000000000000000000000000000000000891",
-  "0x0000000000000000000000000000000000000000000000000000000000000892",
-  "0x0000000000000000000000000000000000000000000000000000000000000893",
-  "0x0000000000000000000000000000000000000000000000000000000000000894",
-  "0x0000000000000000000000000000000000000000000000000000000000000895",
-  "0x0000000000000000000000000000000000000000000000000000000000000896",
-  "0x0000000000000000000000000000000000000000000000000000000000000897",
-  "0x0000000000000000000000000000000000000000000000000000000000000898",
-  "0x0000000000000000000000000000000000000000000000000000000000000899",
-  "0x000000000000000000000000000000000000000000000000000000000000089a",
-  "0x000000000000000000000000000000000000000000000000000000000000089b",
-  "0x000000000000000000000000000000000000000000000000000000000000089c",
-  "0x000000000000000000000000000000000000000000000000000000000000089d",
-  "0x000000000000000000000000000000000000000000000000000000000000089e",
-  "0x000000000000000000000000000000000000000000000000000000000000089f",
-  "0x00000000000000000000000000000000000000000000000000000000000008a0",
-  "0x00000000000000000000000000000000000000000000000000000000000008a1",
-  "0x00000000000000000000000000000000000000000000000000000000000008a2",
-  "0x00000000000000000000000000000000000000000000000000000000000008a3",
-  "0x00000000000000000000000000000000000000000000000000000000000008a4",
-  "0x00000000000000000000000000000000000000000000000000000000000008a5",
-  "0x00000000000000000000000000000000000000000000000000000000000008a6",
-  "0x00000000000000000000000000000000000000000000000000000000000008a7",
-  "0x00000000000000000000000000000000000000000000000000000000000008a8",
-  "0x00000000000000000000000000000000000000000000000000000000000008a9",
-  "0x00000000000000000000000000000000000000000000000000000000000008aa",
-  "0x00000000000000000000000000000000000000000000000000000000000008ab",
-  "0x00000000000000000000000000000000000000000000000000000000000008ac",
-  "0x00000000000000000000000000000000000000000000000000000000000008ad",
-  "0x00000000000000000000000000000000000000000000000000000000000008ae",
-  "0x00000000000000000000000000000000000000000000000000000000000008af",
-  "0x00000000000000000000000000000000000000000000000000000000000008b0",
-  "0x00000000000000000000000000000000000000000000000000000000000008b1",
-  "0x00000000000000000000000000000000000000000000000000000000000008b2",
-  "0x00000000000000000000000000000000000000000000000000000000000008b3",
-  "0x00000000000000000000000000000000000000000000000000000000000008b4",
-  "0x00000000000000000000000000000000000000000000000000000000000008b5",
-  "0x00000000000000000000000000000000000000000000000000000000000008b6",
-  "0x00000000000000000000000000000000000000000000000000000000000008b7",
-  "0x00000000000000000000000000000000000000000000000000000000000008b8",
-  "0x00000000000000000000000000000000000000000000000000000000000008b9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ba",
-  "0x00000000000000000000000000000000000000000000000000000000000008bb",
-  "0x00000000000000000000000000000000000000000000000000000000000008bc",
-  "0x00000000000000000000000000000000000000000000000000000000000008bd",
-  "0x00000000000000000000000000000000000000000000000000000000000008be",
-  "0x00000000000000000000000000000000000000000000000000000000000008bf",
-  "0x00000000000000000000000000000000000000000000000000000000000008c0",
-  "0x00000000000000000000000000000000000000000000000000000000000008c1",
-  "0x00000000000000000000000000000000000000000000000000000000000008c2",
-  "0x00000000000000000000000000000000000000000000000000000000000008c3",
-  "0x00000000000000000000000000000000000000000000000000000000000008c4",
-  "0x00000000000000000000000000000000000000000000000000000000000008c5",
-  "0x00000000000000000000000000000000000000000000000000000000000008c6",
-  "0x00000000000000000000000000000000000000000000000000000000000008c7",
-  "0x00000000000000000000000000000000000000000000000000000000000008c8",
-  "0x00000000000000000000000000000000000000000000000000000000000008c9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ca",
-  "0x00000000000000000000000000000000000000000000000000000000000008cb",
-  "0x00000000000000000000000000000000000000000000000000000000000008cc",
-  "0x00000000000000000000000000000000000000000000000000000000000008cd",
-  "0x00000000000000000000000000000000000000000000000000000000000008ce",
-  "0x00000000000000000000000000000000000000000000000000000000000008cf",
-  "0x00000000000000000000000000000000000000000000000000000000000008d0",
-  "0x00000000000000000000000000000000000000000000000000000000000008d1",
-  "0x00000000000000000000000000000000000000000000000000000000000008d2",
-  "0x00000000000000000000000000000000000000000000000000000000000008d3",
-  "0x00000000000000000000000000000000000000000000000000000000000008d4",
-  "0x00000000000000000000000000000000000000000000000000000000000008d5",
-  "0x00000000000000000000000000000000000000000000000000000000000008d6",
-  "0x00000000000000000000000000000000000000000000000000000000000008d7",
-  "0x00000000000000000000000000000000000000000000000000000000000008d8",
-  "0x00000000000000000000000000000000000000000000000000000000000008d9",
-  "0x00000000000000000000000000000000000000000000000000000000000008da",
-  "0x00000000000000000000000000000000000000000000000000000000000008db",
-  "0x00000000000000000000000000000000000000000000000000000000000008dc",
-  "0x00000000000000000000000000000000000000000000000000000000000008dd",
-  "0x00000000000000000000000000000000000000000000000000000000000008de",
-  "0x00000000000000000000000000000000000000000000000000000000000008df",
-  "0x00000000000000000000000000000000000000000000000000000000000008e0",
-  "0x00000000000000000000000000000000000000000000000000000000000008e1",
-  "0x00000000000000000000000000000000000000000000000000000000000008e2",
-  "0x00000000000000000000000000000000000000000000000000000000000008e3",
-  "0x00000000000000000000000000000000000000000000000000000000000008e4",
-  "0x00000000000000000000000000000000000000000000000000000000000008e5",
-  "0x00000000000000000000000000000000000000000000000000000000000008e6",
-  "0x00000000000000000000000000000000000000000000000000000000000008e7",
-  "0x00000000000000000000000000000000000000000000000000000000000008e8",
-  "0x00000000000000000000000000000000000000000000000000000000000008e9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ea",
-  "0x00000000000000000000000000000000000000000000000000000000000008eb",
-  "0x00000000000000000000000000000000000000000000000000000000000008ec",
-  "0x00000000000000000000000000000000000000000000000000000000000008ed",
-  "0x00000000000000000000000000000000000000000000000000000000000008ee",
-  "0x00000000000000000000000000000000000000000000000000000000000008ef",
-  "0x00000000000000000000000000000000000000000000000000000000000008f0",
-  "0x00000000000000000000000000000000000000000000000000000000000008f1",
-  "0x00000000000000000000000000000000000000000000000000000000000008f2",
-  "0x00000000000000000000000000000000000000000000000000000000000008f3",
-  "0x00000000000000000000000000000000000000000000000000000000000008f4",
-  "0x00000000000000000000000000000000000000000000000000000000000008f5",
-  "0x00000000000000000000000000000000000000000000000000000000000008f6",
-  "0x00000000000000000000000000000000000000000000000000000000000008f7",
-  "0x00000000000000000000000000000000000000000000000000000000000008f8",
-  "0x00000000000000000000000000000000000000000000000000000000000008f9",
-  "0x00000000000000000000000000000000000000000000000000000000000008fa",
-  "0x00000000000000000000000000000000000000000000000000000000000008fb",
-  "0x00000000000000000000000000000000000000000000000000000000000008fc",
-  "0x00000000000000000000000000000000000000000000000000000000000008fd",
-  "0x00000000000000000000000000000000000000000000000000000000000008fe",
-  "0x00000000000000000000000000000000000000000000000000000000000008ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000900",
-  "0x0000000000000000000000000000000000000000000000000000000000000901",
-  "0x0000000000000000000000000000000000000000000000000000000000000902",
-  "0x0000000000000000000000000000000000000000000000000000000000000903",
-  "0x0000000000000000000000000000000000000000000000000000000000000904",
-  "0x0000000000000000000000000000000000000000000000000000000000000905",
-  "0x0000000000000000000000000000000000000000000000000000000000000906",
-  "0x0000000000000000000000000000000000000000000000000000000000000907",
-  "0x0000000000000000000000000000000000000000000000000000000000000908",
-  "0x0000000000000000000000000000000000000000000000000000000000000909",
-  "0x000000000000000000000000000000000000000000000000000000000000090a",
-  "0x000000000000000000000000000000000000000000000000000000000000090b",
-  "0x000000000000000000000000000000000000000000000000000000000000090c",
-  "0x000000000000000000000000000000000000000000000000000000000000090d",
-  "0x000000000000000000000000000000000000000000000000000000000000090e",
-  "0x000000000000000000000000000000000000000000000000000000000000090f",
-  "0x0000000000000000000000000000000000000000000000000000000000000910",
-  "0x0000000000000000000000000000000000000000000000000000000000000911",
-  "0x0000000000000000000000000000000000000000000000000000000000000912",
-  "0x0000000000000000000000000000000000000000000000000000000000000913",
-  "0x0000000000000000000000000000000000000000000000000000000000000914",
-  "0x0000000000000000000000000000000000000000000000000000000000000915",
-  "0x0000000000000000000000000000000000000000000000000000000000000916",
-  "0x0000000000000000000000000000000000000000000000000000000000000917",
-  "0x0000000000000000000000000000000000000000000000000000000000000918",
-  "0x0000000000000000000000000000000000000000000000000000000000000919",
-  "0x000000000000000000000000000000000000000000000000000000000000091a",
-  "0x000000000000000000000000000000000000000000000000000000000000091b",
-  "0x000000000000000000000000000000000000000000000000000000000000091c",
-  "0x000000000000000000000000000000000000000000000000000000000000091d",
-  "0x000000000000000000000000000000000000000000000000000000000000091e",
-  "0x000000000000000000000000000000000000000000000000000000000000091f",
-  "0x0000000000000000000000000000000000000000000000000000000000000920",
-  "0x0000000000000000000000000000000000000000000000000000000000000921",
-  "0x0000000000000000000000000000000000000000000000000000000000000922",
-  "0x0000000000000000000000000000000000000000000000000000000000000923",
-  "0x0000000000000000000000000000000000000000000000000000000000000924",
-  "0x0000000000000000000000000000000000000000000000000000000000000925",
-  "0x0000000000000000000000000000000000000000000000000000000000000926",
-  "0x0000000000000000000000000000000000000000000000000000000000000927",
-  "0x0000000000000000000000000000000000000000000000000000000000000928",
-  "0x0000000000000000000000000000000000000000000000000000000000000929",
-  "0x000000000000000000000000000000000000000000000000000000000000092a",
-  "0x000000000000000000000000000000000000000000000000000000000000092b",
-  "0x000000000000000000000000000000000000000000000000000000000000092c",
-  "0x000000000000000000000000000000000000000000000000000000000000092d",
-  "0x000000000000000000000000000000000000000000000000000000000000092e",
-  "0x000000000000000000000000000000000000000000000000000000000000092f",
-  "0x0000000000000000000000000000000000000000000000000000000000000930",
-  "0x0000000000000000000000000000000000000000000000000000000000000931",
-  "0x0000000000000000000000000000000000000000000000000000000000000932",
-  "0x0000000000000000000000000000000000000000000000000000000000000933",
-  "0x0000000000000000000000000000000000000000000000000000000000000934",
-  "0x0000000000000000000000000000000000000000000000000000000000000935",
-  "0x0000000000000000000000000000000000000000000000000000000000000936",
-  "0x0000000000000000000000000000000000000000000000000000000000000937",
-  "0x0000000000000000000000000000000000000000000000000000000000000938",
-  "0x0000000000000000000000000000000000000000000000000000000000000939",
-  "0x000000000000000000000000000000000000000000000000000000000000093a",
-  "0x000000000000000000000000000000000000000000000000000000000000093b",
-  "0x000000000000000000000000000000000000000000000000000000000000093c",
-  "0x000000000000000000000000000000000000000000000000000000000000093d",
-  "0x000000000000000000000000000000000000000000000000000000000000093e",
-  "0x000000000000000000000000000000000000000000000000000000000000093f",
-  "0x0000000000000000000000000000000000000000000000000000000000000940",
-  "0x0000000000000000000000000000000000000000000000000000000000000941",
-  "0x0000000000000000000000000000000000000000000000000000000000000942",
-  "0x0000000000000000000000000000000000000000000000000000000000000943",
-  "0x0000000000000000000000000000000000000000000000000000000000000944",
-  "0x0000000000000000000000000000000000000000000000000000000000000945",
-  "0x0000000000000000000000000000000000000000000000000000000000000946",
-  "0x0000000000000000000000000000000000000000000000000000000000000947",
-  "0x0000000000000000000000000000000000000000000000000000000000000948",
-  "0x0000000000000000000000000000000000000000000000000000000000000949",
-  "0x000000000000000000000000000000000000000000000000000000000000094a",
-  "0x000000000000000000000000000000000000000000000000000000000000094b",
-  "0x000000000000000000000000000000000000000000000000000000000000094c",
-  "0x000000000000000000000000000000000000000000000000000000000000094d",
-  "0x000000000000000000000000000000000000000000000000000000000000094e",
-  "0x000000000000000000000000000000000000000000000000000000000000094f",
-  "0x0000000000000000000000000000000000000000000000000000000000000950",
-  "0x0000000000000000000000000000000000000000000000000000000000000951",
-  "0x0000000000000000000000000000000000000000000000000000000000000952",
-  "0x0000000000000000000000000000000000000000000000000000000000000953",
-  "0x0000000000000000000000000000000000000000000000000000000000000954",
-  "0x0000000000000000000000000000000000000000000000000000000000000955",
-  "0x0000000000000000000000000000000000000000000000000000000000000956",
-  "0x0000000000000000000000000000000000000000000000000000000000000957",
-  "0x0000000000000000000000000000000000000000000000000000000000000958",
-  "0x0000000000000000000000000000000000000000000000000000000000000959",
-  "0x000000000000000000000000000000000000000000000000000000000000095a",
-  "0x000000000000000000000000000000000000000000000000000000000000095b",
-  "0x000000000000000000000000000000000000000000000000000000000000095c",
-  "0x000000000000000000000000000000000000000000000000000000000000095d",
-  "0x000000000000000000000000000000000000000000000000000000000000095e",
-  "0x000000000000000000000000000000000000000000000000000000000000095f",
-  "0x0000000000000000000000000000000000000000000000000000000000000960",
-  "0x0000000000000000000000000000000000000000000000000000000000000961",
-  "0x0000000000000000000000000000000000000000000000000000000000000962",
-  "0x0000000000000000000000000000000000000000000000000000000000000963",
-  "0x0000000000000000000000000000000000000000000000000000000000000964",
-  "0x0000000000000000000000000000000000000000000000000000000000000965",
-  "0x0000000000000000000000000000000000000000000000000000000000000966",
-  "0x0000000000000000000000000000000000000000000000000000000000000967",
-  "0x0000000000000000000000000000000000000000000000000000000000000968",
-  "0x0000000000000000000000000000000000000000000000000000000000000969",
-  "0x000000000000000000000000000000000000000000000000000000000000096a",
-  "0x000000000000000000000000000000000000000000000000000000000000096b",
-  "0x000000000000000000000000000000000000000000000000000000000000096c",
-  "0x000000000000000000000000000000000000000000000000000000000000096d",
-  "0x000000000000000000000000000000000000000000000000000000000000096e",
-  "0x000000000000000000000000000000000000000000000000000000000000096f",
-  "0x0000000000000000000000000000000000000000000000000000000000000970",
-  "0x0000000000000000000000000000000000000000000000000000000000000971",
-  "0x0000000000000000000000000000000000000000000000000000000000000972",
-  "0x0000000000000000000000000000000000000000000000000000000000000973",
-  "0x0000000000000000000000000000000000000000000000000000000000000974",
-  "0x0000000000000000000000000000000000000000000000000000000000000975",
-  "0x0000000000000000000000000000000000000000000000000000000000000976",
-  "0x0000000000000000000000000000000000000000000000000000000000000977",
-  "0x0000000000000000000000000000000000000000000000000000000000000978",
-  "0x0000000000000000000000000000000000000000000000000000000000000979",
-  "0x000000000000000000000000000000000000000000000000000000000000097a",
-  "0x000000000000000000000000000000000000000000000000000000000000097b",
-  "0x000000000000000000000000000000000000000000000000000000000000097c",
-  "0x000000000000000000000000000000000000000000000000000000000000097d",
-  "0x000000000000000000000000000000000000000000000000000000000000097e",
-  "0x000000000000000000000000000000000000000000000000000000000000097f",
-  "0x0000000000000000000000000000000000000000000000000000000000000980",
-  "0x0000000000000000000000000000000000000000000000000000000000000981",
-  "0x0000000000000000000000000000000000000000000000000000000000000982",
-  "0x0000000000000000000000000000000000000000000000000000000000000983",
-  "0x0000000000000000000000000000000000000000000000000000000000000984",
-  "0x0000000000000000000000000000000000000000000000000000000000000985",
-  "0x0000000000000000000000000000000000000000000000000000000000000986",
-  "0x0000000000000000000000000000000000000000000000000000000000000987",
-  "0x0000000000000000000000000000000000000000000000000000000000000988",
-  "0x0000000000000000000000000000000000000000000000000000000000000989",
-  "0x000000000000000000000000000000000000000000000000000000000000098a",
-  "0x000000000000000000000000000000000000000000000000000000000000098b",
-  "0x000000000000000000000000000000000000000000000000000000000000098c",
-  "0x000000000000000000000000000000000000000000000000000000000000098d",
-  "0x000000000000000000000000000000000000000000000000000000000000098e",
-  "0x000000000000000000000000000000000000000000000000000000000000098f",
-  "0x0000000000000000000000000000000000000000000000000000000000000990",
-  "0x0000000000000000000000000000000000000000000000000000000000000991",
-  "0x0000000000000000000000000000000000000000000000000000000000000992",
-  "0x0000000000000000000000000000000000000000000000000000000000000993",
-  "0x0000000000000000000000000000000000000000000000000000000000000994",
-  "0x0000000000000000000000000000000000000000000000000000000000000995",
-  "0x0000000000000000000000000000000000000000000000000000000000000996",
-  "0x0000000000000000000000000000000000000000000000000000000000000997",
-  "0x0000000000000000000000000000000000000000000000000000000000000998",
-  "0x0000000000000000000000000000000000000000000000000000000000000999",
-  "0x000000000000000000000000000000000000000000000000000000000000099a",
-  "0x000000000000000000000000000000000000000000000000000000000000099b",
-  "0x000000000000000000000000000000000000000000000000000000000000099c",
-  "0x000000000000000000000000000000000000000000000000000000000000099d",
-  "0x000000000000000000000000000000000000000000000000000000000000099e",
-  "0x000000000000000000000000000000000000000000000000000000000000099f",
-  "0x00000000000000000000000000000000000000000000000000000000000009a0",
-  "0x00000000000000000000000000000000000000000000000000000000000009a1",
-  "0x00000000000000000000000000000000000000000000000000000000000009a2",
-  "0x00000000000000000000000000000000000000000000000000000000000009a3",
-  "0x00000000000000000000000000000000000000000000000000000000000009a4",
-  "0x00000000000000000000000000000000000000000000000000000000000009a5",
-  "0x00000000000000000000000000000000000000000000000000000000000009a6",
-  "0x00000000000000000000000000000000000000000000000000000000000009a7",
-  "0x00000000000000000000000000000000000000000000000000000000000009a8",
-  "0x00000000000000000000000000000000000000000000000000000000000009a9",
-  "0x00000000000000000000000000000000000000000000000000000000000009aa",
-  "0x00000000000000000000000000000000000000000000000000000000000009ab",
-  "0x00000000000000000000000000000000000000000000000000000000000009ac",
-  "0x00000000000000000000000000000000000000000000000000000000000009ad",
-  "0x00000000000000000000000000000000000000000000000000000000000009ae",
-  "0x00000000000000000000000000000000000000000000000000000000000009af",
-  "0x00000000000000000000000000000000000000000000000000000000000009b0",
-  "0x00000000000000000000000000000000000000000000000000000000000009b1",
-  "0x00000000000000000000000000000000000000000000000000000000000009b2",
-  "0x00000000000000000000000000000000000000000000000000000000000009b3",
-  "0x00000000000000000000000000000000000000000000000000000000000009b4",
-  "0x00000000000000000000000000000000000000000000000000000000000009b5",
-  "0x00000000000000000000000000000000000000000000000000000000000009b6",
-  "0x00000000000000000000000000000000000000000000000000000000000009b7",
-  "0x00000000000000000000000000000000000000000000000000000000000009b8",
-  "0x00000000000000000000000000000000000000000000000000000000000009b9",
-  "0x00000000000000000000000000000000000000000000000000000000000009ba",
-  "0x00000000000000000000000000000000000000000000000000000000000009bb",
-  "0x00000000000000000000000000000000000000000000000000000000000009bc",
-  "0x00000000000000000000000000000000000000000000000000000000000009bd",
-  "0x00000000000000000000000000000000000000000000000000000000000009be",
-  "0x00000000000000000000000000000000000000000000000000000000000009bf",
-  "0x00000000000000000000000000000000000000000000000000000000000009c0",
-  "0x00000000000000000000000000000000000000000000000000000000000009c1",
-  "0x00000000000000000000000000000000000000000000000000000000000009c2",
-  "0x00000000000000000000000000000000000000000000000000000000000009c3",
-  "0x00000000000000000000000000000000000000000000000000000000000009c4",
-  "0x00000000000000000000000000000000000000000000000000000000000009c5",
-  "0x00000000000000000000000000000000000000000000000000000000000009c6",
-  "0x00000000000000000000000000000000000000000000000000000000000009c7",
-  "0x00000000000000000000000000000000000000000000000000000000000009c8",
-  "0x00000000000000000000000000000000000000000000000000000000000009c9",
-  "0x00000000000000000000000000000000000000000000000000000000000009ca",
-  "0x00000000000000000000000000000000000000000000000000000000000009cb",
-  "0x00000000000000000000000000000000000000000000000000000000000009cc",
-  "0x00000000000000000000000000000000000000000000000000000000000009cd",
-  "0x00000000000000000000000000000000000000000000000000000000000009ce",
-  "0x00000000000000000000000000000000000000000000000000000000000009cf",
-  "0x00000000000000000000000000000000000000000000000000000000000009d0",
-  "0x00000000000000000000000000000000000000000000000000000000000009d1",
-  "0x00000000000000000000000000000000000000000000000000000000000009d2",
-  "0x00000000000000000000000000000000000000000000000000000000000009d3",
-  "0x00000000000000000000000000000000000000000000000000000000000009d4",
-  "0x00000000000000000000000000000000000000000000000000000000000009d5",
-  "0x00000000000000000000000000000000000000000000000000000000000009d6",
-  "0x00000000000000000000000000000000000000000000000000000000000009d7",
-  "0x00000000000000000000000000000000000000000000000000000000000009d8",
-  "0x00000000000000000000000000000000000000000000000000000000000009d9",
-  "0x00000000000000000000000000000000000000000000000000000000000009da",
-  "0x00000000000000000000000000000000000000000000000000000000000009db"
+  "0x00000000000000000000000000000000000000000000000000000000000006db"
 ]
-  num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400"
-  num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400"
+  num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
   [inputs.previous_l1_to_l2]
   root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a"
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml
index e5606c54742f..e04bc7ca5182 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml
@@ -1,15 +1,15 @@
 [inputs]
 l1_to_l2_message_frontier_hint = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb",
+  "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d",
+  "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037",
+  "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da",
+  "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249",
+  "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f",
+  "0x221cf368938c74e4fced9dfb2a8e37cd8a6c57d21385c249f0b5c2412341287f",
+  "0x2c5214dfc4d70d2619fce2a7e02ddcf380576dca42b66c9215c7d8d1ec154116",
+  "0x13abc9bba431e6930c169f5daeb60aedbb27d7618c7ff88b3b4ec1c6de1d6bb8",
   "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f",
   "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad",
   "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da",
@@ -561,7 +561,7 @@ new_archive_sibling_path = [
     accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0"
 
       [inputs.previous_rollups.public_inputs.constants]
-      vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c"
+      vk_tree_root = "0x1d366660277d0da1e9c56a961b6d5b5cac2b74641eba14de96aff4f319db5556"
       protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b"
       prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
@@ -570,8 +570,8 @@ new_archive_sibling_path = [
         next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001"
 
         [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot]
-        root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+        root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
         [inputs.previous_rollups.public_inputs.constants.global_variables]
         chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
@@ -642,10 +642,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b7d1b44c"
 ]
         state = [
-  "0x04aaabffb7f35f45dea8e9b68dd48ee04d95e0edd37d79f6f21dbe83f838f018",
-  "0x258263cc3cf0e87edfb02817e9f7d9dbc1e826b2b3e5b473bc4661e683c698b0",
-  "0x0d2302e54e05898b7b0659dc607042b33f5d94d6cfaff90d6464952675d81ecc",
-  "0x272a09845b81d4c6da506c4c7ae326ff16683d03d128a319ed2457249ee1f191"
+  "0x1b83036dd98a395dc161e3457ed7cd848281b931b82ead88381f389fc8999240",
+  "0x0d61a354e7ac0e23a59d812c33efbc4e102b94e82a8737d78b9a5d3255612309",
+  "0x20c7477934a74687280e4605407f21b49656fbe1c21d4453866cd710cc4b44b7",
+  "0x12a12ae4064c03e193958f7448ca6b29c935e1e6576686c5a09173680738be6f"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002"
         squeeze_mode = false
@@ -656,10 +656,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x1fc39d0a428c8536dbca551ea79848acf67d89d090fd8c643c7d90f2e8f32340",
   "0x12ce5a49a1ceca53ada7bee003f929bbd65abaa74e8072a81f304c2c96c44e31",
   "0x2dd71474f7775d87b6c2986ace5f654686583f0970d7400b1ccf8096dad131b5",
-  "0x0aca02f69b05a42958d30ced7da19a9e135e0c83b75e72ae5f7e2bec714a418f",
+  "0x22fe3deda3c756121ae860fd950eef8dc76c6e4db472e345da469025560db9d8",
   "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d",
   "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41",
-  "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd"
+  "0x0a082458fe660d17b7c5348e39012f798c9805cc616347c76862995fb24394e9"
 ]
 
       [inputs.previous_rollups.vk_data.vk]
@@ -1273,7 +1273,7 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
     accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
       [inputs.previous_rollups.public_inputs.constants]
-      vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c"
+      vk_tree_root = "0x1d366660277d0da1e9c56a961b6d5b5cac2b74641eba14de96aff4f319db5556"
       protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b"
       prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
@@ -1282,8 +1282,8 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
         next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001"
 
         [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot]
-        root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+        root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
         [inputs.previous_rollups.public_inputs.constants.global_variables]
         chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
@@ -1336,10 +1336,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b7d1b44c"
 ]
         state = [
-  "0x04aaabffb7f35f45dea8e9b68dd48ee04d95e0edd37d79f6f21dbe83f838f018",
-  "0x258263cc3cf0e87edfb02817e9f7d9dbc1e826b2b3e5b473bc4661e683c698b0",
-  "0x0d2302e54e05898b7b0659dc607042b33f5d94d6cfaff90d6464952675d81ecc",
-  "0x272a09845b81d4c6da506c4c7ae326ff16683d03d128a319ed2457249ee1f191"
+  "0x1b83036dd98a395dc161e3457ed7cd848281b931b82ead88381f389fc8999240",
+  "0x0d61a354e7ac0e23a59d812c33efbc4e102b94e82a8737d78b9a5d3255612309",
+  "0x20c7477934a74687280e4605407f21b49656fbe1c21d4453866cd710cc4b44b7",
+  "0x12a12ae4064c03e193958f7448ca6b29c935e1e6576686c5a09173680738be6f"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002"
         squeeze_mode = false
@@ -1354,10 +1354,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b7e5c34d"
 ]
         state = [
-  "0x13449344a1e851eb9122ed82ff8fbf021f2e74d74bac4f360f0964c9b5216673",
-  "0x0d63e47877339d61d174600690b717a4bab73e17a72a9cacef740ad257ad4908",
-  "0x075e35308cabf2299ccd38d2f5957b30ee819ae7a04dca5cfdbaac40d88c16b8",
-  "0x2a429fa7f6cfbf48c22feb2f318aaff592c330dc1abc521ec0966efe53cf536d"
+  "0x2bae25761da1bbec30d8cf6acd0d0811d018fa18418daf08cb8b4f7cbd2334c9",
+  "0x010a0da119110a6e3eb65a562990761b0f7ce2026bf47f6d68bad8d6908883a8",
+  "0x1abcbd3c1f2cc0e08d40d52546891d653509e07aad897c9917313e9de7422122",
+  "0x1d08092a71254cf89337f83889af51efd8043033b8bb3ddaeb5f3a8965928abf"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001"
         squeeze_mode = false
@@ -1366,12 +1366,12 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
     leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000008"
     sibling_path = [
   "0x10b6730f1d1e9c6bf8d7c4b42b64b40d2603e3ae6ddbd464c3d8fcfb9e06e6d4",
-  "0x014ffec160e37b6cb713c1a4e6e7058964dde1733e6734520ed72f72fd262919",
-  "0x196cbe2980734bc5d21b53464a1d00c06dad0febdec75822d79d6933dff40579",
+  "0x171bffeec1260bb9f698111c91ca858d65feda265f392e620d474cb0cd818d11",
+  "0x16be345917fc7e9b43ef91c1e90e4aad1966337808cf67897c58f7a77a81f907",
   "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd",
   "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d",
   "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41",
-  "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd"
+  "0x0a082458fe660d17b7c5348e39012f798c9805cc616347c76862995fb24394e9"
 ]
 
       [inputs.previous_rollups.vk_data.vk]
@@ -1751,778 +1751,9 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000000006d8",
   "0x00000000000000000000000000000000000000000000000000000000000006d9",
   "0x00000000000000000000000000000000000000000000000000000000000006da",
-  "0x00000000000000000000000000000000000000000000000000000000000006db",
-  "0x00000000000000000000000000000000000000000000000000000000000006dc",
-  "0x00000000000000000000000000000000000000000000000000000000000006dd",
-  "0x00000000000000000000000000000000000000000000000000000000000006de",
-  "0x00000000000000000000000000000000000000000000000000000000000006df",
-  "0x00000000000000000000000000000000000000000000000000000000000006e0",
-  "0x00000000000000000000000000000000000000000000000000000000000006e1",
-  "0x00000000000000000000000000000000000000000000000000000000000006e2",
-  "0x00000000000000000000000000000000000000000000000000000000000006e3",
-  "0x00000000000000000000000000000000000000000000000000000000000006e4",
-  "0x00000000000000000000000000000000000000000000000000000000000006e5",
-  "0x00000000000000000000000000000000000000000000000000000000000006e6",
-  "0x00000000000000000000000000000000000000000000000000000000000006e7",
-  "0x00000000000000000000000000000000000000000000000000000000000006e8",
-  "0x00000000000000000000000000000000000000000000000000000000000006e9",
-  "0x00000000000000000000000000000000000000000000000000000000000006ea",
-  "0x00000000000000000000000000000000000000000000000000000000000006eb",
-  "0x00000000000000000000000000000000000000000000000000000000000006ec",
-  "0x00000000000000000000000000000000000000000000000000000000000006ed",
-  "0x00000000000000000000000000000000000000000000000000000000000006ee",
-  "0x00000000000000000000000000000000000000000000000000000000000006ef",
-  "0x00000000000000000000000000000000000000000000000000000000000006f0",
-  "0x00000000000000000000000000000000000000000000000000000000000006f1",
-  "0x00000000000000000000000000000000000000000000000000000000000006f2",
-  "0x00000000000000000000000000000000000000000000000000000000000006f3",
-  "0x00000000000000000000000000000000000000000000000000000000000006f4",
-  "0x00000000000000000000000000000000000000000000000000000000000006f5",
-  "0x00000000000000000000000000000000000000000000000000000000000006f6",
-  "0x00000000000000000000000000000000000000000000000000000000000006f7",
-  "0x00000000000000000000000000000000000000000000000000000000000006f8",
-  "0x00000000000000000000000000000000000000000000000000000000000006f9",
-  "0x00000000000000000000000000000000000000000000000000000000000006fa",
-  "0x00000000000000000000000000000000000000000000000000000000000006fb",
-  "0x00000000000000000000000000000000000000000000000000000000000006fc",
-  "0x00000000000000000000000000000000000000000000000000000000000006fd",
-  "0x00000000000000000000000000000000000000000000000000000000000006fe",
-  "0x00000000000000000000000000000000000000000000000000000000000006ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000700",
-  "0x0000000000000000000000000000000000000000000000000000000000000701",
-  "0x0000000000000000000000000000000000000000000000000000000000000702",
-  "0x0000000000000000000000000000000000000000000000000000000000000703",
-  "0x0000000000000000000000000000000000000000000000000000000000000704",
-  "0x0000000000000000000000000000000000000000000000000000000000000705",
-  "0x0000000000000000000000000000000000000000000000000000000000000706",
-  "0x0000000000000000000000000000000000000000000000000000000000000707",
-  "0x0000000000000000000000000000000000000000000000000000000000000708",
-  "0x0000000000000000000000000000000000000000000000000000000000000709",
-  "0x000000000000000000000000000000000000000000000000000000000000070a",
-  "0x000000000000000000000000000000000000000000000000000000000000070b",
-  "0x000000000000000000000000000000000000000000000000000000000000070c",
-  "0x000000000000000000000000000000000000000000000000000000000000070d",
-  "0x000000000000000000000000000000000000000000000000000000000000070e",
-  "0x000000000000000000000000000000000000000000000000000000000000070f",
-  "0x0000000000000000000000000000000000000000000000000000000000000710",
-  "0x0000000000000000000000000000000000000000000000000000000000000711",
-  "0x0000000000000000000000000000000000000000000000000000000000000712",
-  "0x0000000000000000000000000000000000000000000000000000000000000713",
-  "0x0000000000000000000000000000000000000000000000000000000000000714",
-  "0x0000000000000000000000000000000000000000000000000000000000000715",
-  "0x0000000000000000000000000000000000000000000000000000000000000716",
-  "0x0000000000000000000000000000000000000000000000000000000000000717",
-  "0x0000000000000000000000000000000000000000000000000000000000000718",
-  "0x0000000000000000000000000000000000000000000000000000000000000719",
-  "0x000000000000000000000000000000000000000000000000000000000000071a",
-  "0x000000000000000000000000000000000000000000000000000000000000071b",
-  "0x000000000000000000000000000000000000000000000000000000000000071c",
-  "0x000000000000000000000000000000000000000000000000000000000000071d",
-  "0x000000000000000000000000000000000000000000000000000000000000071e",
-  "0x000000000000000000000000000000000000000000000000000000000000071f",
-  "0x0000000000000000000000000000000000000000000000000000000000000720",
-  "0x0000000000000000000000000000000000000000000000000000000000000721",
-  "0x0000000000000000000000000000000000000000000000000000000000000722",
-  "0x0000000000000000000000000000000000000000000000000000000000000723",
-  "0x0000000000000000000000000000000000000000000000000000000000000724",
-  "0x0000000000000000000000000000000000000000000000000000000000000725",
-  "0x0000000000000000000000000000000000000000000000000000000000000726",
-  "0x0000000000000000000000000000000000000000000000000000000000000727",
-  "0x0000000000000000000000000000000000000000000000000000000000000728",
-  "0x0000000000000000000000000000000000000000000000000000000000000729",
-  "0x000000000000000000000000000000000000000000000000000000000000072a",
-  "0x000000000000000000000000000000000000000000000000000000000000072b",
-  "0x000000000000000000000000000000000000000000000000000000000000072c",
-  "0x000000000000000000000000000000000000000000000000000000000000072d",
-  "0x000000000000000000000000000000000000000000000000000000000000072e",
-  "0x000000000000000000000000000000000000000000000000000000000000072f",
-  "0x0000000000000000000000000000000000000000000000000000000000000730",
-  "0x0000000000000000000000000000000000000000000000000000000000000731",
-  "0x0000000000000000000000000000000000000000000000000000000000000732",
-  "0x0000000000000000000000000000000000000000000000000000000000000733",
-  "0x0000000000000000000000000000000000000000000000000000000000000734",
-  "0x0000000000000000000000000000000000000000000000000000000000000735",
-  "0x0000000000000000000000000000000000000000000000000000000000000736",
-  "0x0000000000000000000000000000000000000000000000000000000000000737",
-  "0x0000000000000000000000000000000000000000000000000000000000000738",
-  "0x0000000000000000000000000000000000000000000000000000000000000739",
-  "0x000000000000000000000000000000000000000000000000000000000000073a",
-  "0x000000000000000000000000000000000000000000000000000000000000073b",
-  "0x000000000000000000000000000000000000000000000000000000000000073c",
-  "0x000000000000000000000000000000000000000000000000000000000000073d",
-  "0x000000000000000000000000000000000000000000000000000000000000073e",
-  "0x000000000000000000000000000000000000000000000000000000000000073f",
-  "0x0000000000000000000000000000000000000000000000000000000000000740",
-  "0x0000000000000000000000000000000000000000000000000000000000000741",
-  "0x0000000000000000000000000000000000000000000000000000000000000742",
-  "0x0000000000000000000000000000000000000000000000000000000000000743",
-  "0x0000000000000000000000000000000000000000000000000000000000000744",
-  "0x0000000000000000000000000000000000000000000000000000000000000745",
-  "0x0000000000000000000000000000000000000000000000000000000000000746",
-  "0x0000000000000000000000000000000000000000000000000000000000000747",
-  "0x0000000000000000000000000000000000000000000000000000000000000748",
-  "0x0000000000000000000000000000000000000000000000000000000000000749",
-  "0x000000000000000000000000000000000000000000000000000000000000074a",
-  "0x000000000000000000000000000000000000000000000000000000000000074b",
-  "0x000000000000000000000000000000000000000000000000000000000000074c",
-  "0x000000000000000000000000000000000000000000000000000000000000074d",
-  "0x000000000000000000000000000000000000000000000000000000000000074e",
-  "0x000000000000000000000000000000000000000000000000000000000000074f",
-  "0x0000000000000000000000000000000000000000000000000000000000000750",
-  "0x0000000000000000000000000000000000000000000000000000000000000751",
-  "0x0000000000000000000000000000000000000000000000000000000000000752",
-  "0x0000000000000000000000000000000000000000000000000000000000000753",
-  "0x0000000000000000000000000000000000000000000000000000000000000754",
-  "0x0000000000000000000000000000000000000000000000000000000000000755",
-  "0x0000000000000000000000000000000000000000000000000000000000000756",
-  "0x0000000000000000000000000000000000000000000000000000000000000757",
-  "0x0000000000000000000000000000000000000000000000000000000000000758",
-  "0x0000000000000000000000000000000000000000000000000000000000000759",
-  "0x000000000000000000000000000000000000000000000000000000000000075a",
-  "0x000000000000000000000000000000000000000000000000000000000000075b",
-  "0x000000000000000000000000000000000000000000000000000000000000075c",
-  "0x000000000000000000000000000000000000000000000000000000000000075d",
-  "0x000000000000000000000000000000000000000000000000000000000000075e",
-  "0x000000000000000000000000000000000000000000000000000000000000075f",
-  "0x0000000000000000000000000000000000000000000000000000000000000760",
-  "0x0000000000000000000000000000000000000000000000000000000000000761",
-  "0x0000000000000000000000000000000000000000000000000000000000000762",
-  "0x0000000000000000000000000000000000000000000000000000000000000763",
-  "0x0000000000000000000000000000000000000000000000000000000000000764",
-  "0x0000000000000000000000000000000000000000000000000000000000000765",
-  "0x0000000000000000000000000000000000000000000000000000000000000766",
-  "0x0000000000000000000000000000000000000000000000000000000000000767",
-  "0x0000000000000000000000000000000000000000000000000000000000000768",
-  "0x0000000000000000000000000000000000000000000000000000000000000769",
-  "0x000000000000000000000000000000000000000000000000000000000000076a",
-  "0x000000000000000000000000000000000000000000000000000000000000076b",
-  "0x000000000000000000000000000000000000000000000000000000000000076c",
-  "0x000000000000000000000000000000000000000000000000000000000000076d",
-  "0x000000000000000000000000000000000000000000000000000000000000076e",
-  "0x000000000000000000000000000000000000000000000000000000000000076f",
-  "0x0000000000000000000000000000000000000000000000000000000000000770",
-  "0x0000000000000000000000000000000000000000000000000000000000000771",
-  "0x0000000000000000000000000000000000000000000000000000000000000772",
-  "0x0000000000000000000000000000000000000000000000000000000000000773",
-  "0x0000000000000000000000000000000000000000000000000000000000000774",
-  "0x0000000000000000000000000000000000000000000000000000000000000775",
-  "0x0000000000000000000000000000000000000000000000000000000000000776",
-  "0x0000000000000000000000000000000000000000000000000000000000000777",
-  "0x0000000000000000000000000000000000000000000000000000000000000778",
-  "0x0000000000000000000000000000000000000000000000000000000000000779",
-  "0x000000000000000000000000000000000000000000000000000000000000077a",
-  "0x000000000000000000000000000000000000000000000000000000000000077b",
-  "0x000000000000000000000000000000000000000000000000000000000000077c",
-  "0x000000000000000000000000000000000000000000000000000000000000077d",
-  "0x000000000000000000000000000000000000000000000000000000000000077e",
-  "0x000000000000000000000000000000000000000000000000000000000000077f",
-  "0x0000000000000000000000000000000000000000000000000000000000000780",
-  "0x0000000000000000000000000000000000000000000000000000000000000781",
-  "0x0000000000000000000000000000000000000000000000000000000000000782",
-  "0x0000000000000000000000000000000000000000000000000000000000000783",
-  "0x0000000000000000000000000000000000000000000000000000000000000784",
-  "0x0000000000000000000000000000000000000000000000000000000000000785",
-  "0x0000000000000000000000000000000000000000000000000000000000000786",
-  "0x0000000000000000000000000000000000000000000000000000000000000787",
-  "0x0000000000000000000000000000000000000000000000000000000000000788",
-  "0x0000000000000000000000000000000000000000000000000000000000000789",
-  "0x000000000000000000000000000000000000000000000000000000000000078a",
-  "0x000000000000000000000000000000000000000000000000000000000000078b",
-  "0x000000000000000000000000000000000000000000000000000000000000078c",
-  "0x000000000000000000000000000000000000000000000000000000000000078d",
-  "0x000000000000000000000000000000000000000000000000000000000000078e",
-  "0x000000000000000000000000000000000000000000000000000000000000078f",
-  "0x0000000000000000000000000000000000000000000000000000000000000790",
-  "0x0000000000000000000000000000000000000000000000000000000000000791",
-  "0x0000000000000000000000000000000000000000000000000000000000000792",
-  "0x0000000000000000000000000000000000000000000000000000000000000793",
-  "0x0000000000000000000000000000000000000000000000000000000000000794",
-  "0x0000000000000000000000000000000000000000000000000000000000000795",
-  "0x0000000000000000000000000000000000000000000000000000000000000796",
-  "0x0000000000000000000000000000000000000000000000000000000000000797",
-  "0x0000000000000000000000000000000000000000000000000000000000000798",
-  "0x0000000000000000000000000000000000000000000000000000000000000799",
-  "0x000000000000000000000000000000000000000000000000000000000000079a",
-  "0x000000000000000000000000000000000000000000000000000000000000079b",
-  "0x000000000000000000000000000000000000000000000000000000000000079c",
-  "0x000000000000000000000000000000000000000000000000000000000000079d",
-  "0x000000000000000000000000000000000000000000000000000000000000079e",
-  "0x000000000000000000000000000000000000000000000000000000000000079f",
-  "0x00000000000000000000000000000000000000000000000000000000000007a0",
-  "0x00000000000000000000000000000000000000000000000000000000000007a1",
-  "0x00000000000000000000000000000000000000000000000000000000000007a2",
-  "0x00000000000000000000000000000000000000000000000000000000000007a3",
-  "0x00000000000000000000000000000000000000000000000000000000000007a4",
-  "0x00000000000000000000000000000000000000000000000000000000000007a5",
-  "0x00000000000000000000000000000000000000000000000000000000000007a6",
-  "0x00000000000000000000000000000000000000000000000000000000000007a7",
-  "0x00000000000000000000000000000000000000000000000000000000000007a8",
-  "0x00000000000000000000000000000000000000000000000000000000000007a9",
-  "0x00000000000000000000000000000000000000000000000000000000000007aa",
-  "0x00000000000000000000000000000000000000000000000000000000000007ab",
-  "0x00000000000000000000000000000000000000000000000000000000000007ac",
-  "0x00000000000000000000000000000000000000000000000000000000000007ad",
-  "0x00000000000000000000000000000000000000000000000000000000000007ae",
-  "0x00000000000000000000000000000000000000000000000000000000000007af",
-  "0x00000000000000000000000000000000000000000000000000000000000007b0",
-  "0x00000000000000000000000000000000000000000000000000000000000007b1",
-  "0x00000000000000000000000000000000000000000000000000000000000007b2",
-  "0x00000000000000000000000000000000000000000000000000000000000007b3",
-  "0x00000000000000000000000000000000000000000000000000000000000007b4",
-  "0x00000000000000000000000000000000000000000000000000000000000007b5",
-  "0x00000000000000000000000000000000000000000000000000000000000007b6",
-  "0x00000000000000000000000000000000000000000000000000000000000007b7",
-  "0x00000000000000000000000000000000000000000000000000000000000007b8",
-  "0x00000000000000000000000000000000000000000000000000000000000007b9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ba",
-  "0x00000000000000000000000000000000000000000000000000000000000007bb",
-  "0x00000000000000000000000000000000000000000000000000000000000007bc",
-  "0x00000000000000000000000000000000000000000000000000000000000007bd",
-  "0x00000000000000000000000000000000000000000000000000000000000007be",
-  "0x00000000000000000000000000000000000000000000000000000000000007bf",
-  "0x00000000000000000000000000000000000000000000000000000000000007c0",
-  "0x00000000000000000000000000000000000000000000000000000000000007c1",
-  "0x00000000000000000000000000000000000000000000000000000000000007c2",
-  "0x00000000000000000000000000000000000000000000000000000000000007c3",
-  "0x00000000000000000000000000000000000000000000000000000000000007c4",
-  "0x00000000000000000000000000000000000000000000000000000000000007c5",
-  "0x00000000000000000000000000000000000000000000000000000000000007c6",
-  "0x00000000000000000000000000000000000000000000000000000000000007c7",
-  "0x00000000000000000000000000000000000000000000000000000000000007c8",
-  "0x00000000000000000000000000000000000000000000000000000000000007c9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ca",
-  "0x00000000000000000000000000000000000000000000000000000000000007cb",
-  "0x00000000000000000000000000000000000000000000000000000000000007cc",
-  "0x00000000000000000000000000000000000000000000000000000000000007cd",
-  "0x00000000000000000000000000000000000000000000000000000000000007ce",
-  "0x00000000000000000000000000000000000000000000000000000000000007cf",
-  "0x00000000000000000000000000000000000000000000000000000000000007d0",
-  "0x00000000000000000000000000000000000000000000000000000000000007d1",
-  "0x00000000000000000000000000000000000000000000000000000000000007d2",
-  "0x00000000000000000000000000000000000000000000000000000000000007d3",
-  "0x00000000000000000000000000000000000000000000000000000000000007d4",
-  "0x00000000000000000000000000000000000000000000000000000000000007d5",
-  "0x00000000000000000000000000000000000000000000000000000000000007d6",
-  "0x00000000000000000000000000000000000000000000000000000000000007d7",
-  "0x00000000000000000000000000000000000000000000000000000000000007d8",
-  "0x00000000000000000000000000000000000000000000000000000000000007d9",
-  "0x00000000000000000000000000000000000000000000000000000000000007da",
-  "0x00000000000000000000000000000000000000000000000000000000000007db",
-  "0x00000000000000000000000000000000000000000000000000000000000007dc",
-  "0x00000000000000000000000000000000000000000000000000000000000007dd",
-  "0x00000000000000000000000000000000000000000000000000000000000007de",
-  "0x00000000000000000000000000000000000000000000000000000000000007df",
-  "0x00000000000000000000000000000000000000000000000000000000000007e0",
-  "0x00000000000000000000000000000000000000000000000000000000000007e1",
-  "0x00000000000000000000000000000000000000000000000000000000000007e2",
-  "0x00000000000000000000000000000000000000000000000000000000000007e3",
-  "0x00000000000000000000000000000000000000000000000000000000000007e4",
-  "0x00000000000000000000000000000000000000000000000000000000000007e5",
-  "0x00000000000000000000000000000000000000000000000000000000000007e6",
-  "0x00000000000000000000000000000000000000000000000000000000000007e7",
-  "0x00000000000000000000000000000000000000000000000000000000000007e8",
-  "0x00000000000000000000000000000000000000000000000000000000000007e9",
-  "0x00000000000000000000000000000000000000000000000000000000000007ea",
-  "0x00000000000000000000000000000000000000000000000000000000000007eb",
-  "0x00000000000000000000000000000000000000000000000000000000000007ec",
-  "0x00000000000000000000000000000000000000000000000000000000000007ed",
-  "0x00000000000000000000000000000000000000000000000000000000000007ee",
-  "0x00000000000000000000000000000000000000000000000000000000000007ef",
-  "0x00000000000000000000000000000000000000000000000000000000000007f0",
-  "0x00000000000000000000000000000000000000000000000000000000000007f1",
-  "0x00000000000000000000000000000000000000000000000000000000000007f2",
-  "0x00000000000000000000000000000000000000000000000000000000000007f3",
-  "0x00000000000000000000000000000000000000000000000000000000000007f4",
-  "0x00000000000000000000000000000000000000000000000000000000000007f5",
-  "0x00000000000000000000000000000000000000000000000000000000000007f6",
-  "0x00000000000000000000000000000000000000000000000000000000000007f7",
-  "0x00000000000000000000000000000000000000000000000000000000000007f8",
-  "0x00000000000000000000000000000000000000000000000000000000000007f9",
-  "0x00000000000000000000000000000000000000000000000000000000000007fa",
-  "0x00000000000000000000000000000000000000000000000000000000000007fb",
-  "0x00000000000000000000000000000000000000000000000000000000000007fc",
-  "0x00000000000000000000000000000000000000000000000000000000000007fd",
-  "0x00000000000000000000000000000000000000000000000000000000000007fe",
-  "0x00000000000000000000000000000000000000000000000000000000000007ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000800",
-  "0x0000000000000000000000000000000000000000000000000000000000000801",
-  "0x0000000000000000000000000000000000000000000000000000000000000802",
-  "0x0000000000000000000000000000000000000000000000000000000000000803",
-  "0x0000000000000000000000000000000000000000000000000000000000000804",
-  "0x0000000000000000000000000000000000000000000000000000000000000805",
-  "0x0000000000000000000000000000000000000000000000000000000000000806",
-  "0x0000000000000000000000000000000000000000000000000000000000000807",
-  "0x0000000000000000000000000000000000000000000000000000000000000808",
-  "0x0000000000000000000000000000000000000000000000000000000000000809",
-  "0x000000000000000000000000000000000000000000000000000000000000080a",
-  "0x000000000000000000000000000000000000000000000000000000000000080b",
-  "0x000000000000000000000000000000000000000000000000000000000000080c",
-  "0x000000000000000000000000000000000000000000000000000000000000080d",
-  "0x000000000000000000000000000000000000000000000000000000000000080e",
-  "0x000000000000000000000000000000000000000000000000000000000000080f",
-  "0x0000000000000000000000000000000000000000000000000000000000000810",
-  "0x0000000000000000000000000000000000000000000000000000000000000811",
-  "0x0000000000000000000000000000000000000000000000000000000000000812",
-  "0x0000000000000000000000000000000000000000000000000000000000000813",
-  "0x0000000000000000000000000000000000000000000000000000000000000814",
-  "0x0000000000000000000000000000000000000000000000000000000000000815",
-  "0x0000000000000000000000000000000000000000000000000000000000000816",
-  "0x0000000000000000000000000000000000000000000000000000000000000817",
-  "0x0000000000000000000000000000000000000000000000000000000000000818",
-  "0x0000000000000000000000000000000000000000000000000000000000000819",
-  "0x000000000000000000000000000000000000000000000000000000000000081a",
-  "0x000000000000000000000000000000000000000000000000000000000000081b",
-  "0x000000000000000000000000000000000000000000000000000000000000081c",
-  "0x000000000000000000000000000000000000000000000000000000000000081d",
-  "0x000000000000000000000000000000000000000000000000000000000000081e",
-  "0x000000000000000000000000000000000000000000000000000000000000081f",
-  "0x0000000000000000000000000000000000000000000000000000000000000820",
-  "0x0000000000000000000000000000000000000000000000000000000000000821",
-  "0x0000000000000000000000000000000000000000000000000000000000000822",
-  "0x0000000000000000000000000000000000000000000000000000000000000823",
-  "0x0000000000000000000000000000000000000000000000000000000000000824",
-  "0x0000000000000000000000000000000000000000000000000000000000000825",
-  "0x0000000000000000000000000000000000000000000000000000000000000826",
-  "0x0000000000000000000000000000000000000000000000000000000000000827",
-  "0x0000000000000000000000000000000000000000000000000000000000000828",
-  "0x0000000000000000000000000000000000000000000000000000000000000829",
-  "0x000000000000000000000000000000000000000000000000000000000000082a",
-  "0x000000000000000000000000000000000000000000000000000000000000082b",
-  "0x000000000000000000000000000000000000000000000000000000000000082c",
-  "0x000000000000000000000000000000000000000000000000000000000000082d",
-  "0x000000000000000000000000000000000000000000000000000000000000082e",
-  "0x000000000000000000000000000000000000000000000000000000000000082f",
-  "0x0000000000000000000000000000000000000000000000000000000000000830",
-  "0x0000000000000000000000000000000000000000000000000000000000000831",
-  "0x0000000000000000000000000000000000000000000000000000000000000832",
-  "0x0000000000000000000000000000000000000000000000000000000000000833",
-  "0x0000000000000000000000000000000000000000000000000000000000000834",
-  "0x0000000000000000000000000000000000000000000000000000000000000835",
-  "0x0000000000000000000000000000000000000000000000000000000000000836",
-  "0x0000000000000000000000000000000000000000000000000000000000000837",
-  "0x0000000000000000000000000000000000000000000000000000000000000838",
-  "0x0000000000000000000000000000000000000000000000000000000000000839",
-  "0x000000000000000000000000000000000000000000000000000000000000083a",
-  "0x000000000000000000000000000000000000000000000000000000000000083b",
-  "0x000000000000000000000000000000000000000000000000000000000000083c",
-  "0x000000000000000000000000000000000000000000000000000000000000083d",
-  "0x000000000000000000000000000000000000000000000000000000000000083e",
-  "0x000000000000000000000000000000000000000000000000000000000000083f",
-  "0x0000000000000000000000000000000000000000000000000000000000000840",
-  "0x0000000000000000000000000000000000000000000000000000000000000841",
-  "0x0000000000000000000000000000000000000000000000000000000000000842",
-  "0x0000000000000000000000000000000000000000000000000000000000000843",
-  "0x0000000000000000000000000000000000000000000000000000000000000844",
-  "0x0000000000000000000000000000000000000000000000000000000000000845",
-  "0x0000000000000000000000000000000000000000000000000000000000000846",
-  "0x0000000000000000000000000000000000000000000000000000000000000847",
-  "0x0000000000000000000000000000000000000000000000000000000000000848",
-  "0x0000000000000000000000000000000000000000000000000000000000000849",
-  "0x000000000000000000000000000000000000000000000000000000000000084a",
-  "0x000000000000000000000000000000000000000000000000000000000000084b",
-  "0x000000000000000000000000000000000000000000000000000000000000084c",
-  "0x000000000000000000000000000000000000000000000000000000000000084d",
-  "0x000000000000000000000000000000000000000000000000000000000000084e",
-  "0x000000000000000000000000000000000000000000000000000000000000084f",
-  "0x0000000000000000000000000000000000000000000000000000000000000850",
-  "0x0000000000000000000000000000000000000000000000000000000000000851",
-  "0x0000000000000000000000000000000000000000000000000000000000000852",
-  "0x0000000000000000000000000000000000000000000000000000000000000853",
-  "0x0000000000000000000000000000000000000000000000000000000000000854",
-  "0x0000000000000000000000000000000000000000000000000000000000000855",
-  "0x0000000000000000000000000000000000000000000000000000000000000856",
-  "0x0000000000000000000000000000000000000000000000000000000000000857",
-  "0x0000000000000000000000000000000000000000000000000000000000000858",
-  "0x0000000000000000000000000000000000000000000000000000000000000859",
-  "0x000000000000000000000000000000000000000000000000000000000000085a",
-  "0x000000000000000000000000000000000000000000000000000000000000085b",
-  "0x000000000000000000000000000000000000000000000000000000000000085c",
-  "0x000000000000000000000000000000000000000000000000000000000000085d",
-  "0x000000000000000000000000000000000000000000000000000000000000085e",
-  "0x000000000000000000000000000000000000000000000000000000000000085f",
-  "0x0000000000000000000000000000000000000000000000000000000000000860",
-  "0x0000000000000000000000000000000000000000000000000000000000000861",
-  "0x0000000000000000000000000000000000000000000000000000000000000862",
-  "0x0000000000000000000000000000000000000000000000000000000000000863",
-  "0x0000000000000000000000000000000000000000000000000000000000000864",
-  "0x0000000000000000000000000000000000000000000000000000000000000865",
-  "0x0000000000000000000000000000000000000000000000000000000000000866",
-  "0x0000000000000000000000000000000000000000000000000000000000000867",
-  "0x0000000000000000000000000000000000000000000000000000000000000868",
-  "0x0000000000000000000000000000000000000000000000000000000000000869",
-  "0x000000000000000000000000000000000000000000000000000000000000086a",
-  "0x000000000000000000000000000000000000000000000000000000000000086b",
-  "0x000000000000000000000000000000000000000000000000000000000000086c",
-  "0x000000000000000000000000000000000000000000000000000000000000086d",
-  "0x000000000000000000000000000000000000000000000000000000000000086e",
-  "0x000000000000000000000000000000000000000000000000000000000000086f",
-  "0x0000000000000000000000000000000000000000000000000000000000000870",
-  "0x0000000000000000000000000000000000000000000000000000000000000871",
-  "0x0000000000000000000000000000000000000000000000000000000000000872",
-  "0x0000000000000000000000000000000000000000000000000000000000000873",
-  "0x0000000000000000000000000000000000000000000000000000000000000874",
-  "0x0000000000000000000000000000000000000000000000000000000000000875",
-  "0x0000000000000000000000000000000000000000000000000000000000000876",
-  "0x0000000000000000000000000000000000000000000000000000000000000877",
-  "0x0000000000000000000000000000000000000000000000000000000000000878",
-  "0x0000000000000000000000000000000000000000000000000000000000000879",
-  "0x000000000000000000000000000000000000000000000000000000000000087a",
-  "0x000000000000000000000000000000000000000000000000000000000000087b",
-  "0x000000000000000000000000000000000000000000000000000000000000087c",
-  "0x000000000000000000000000000000000000000000000000000000000000087d",
-  "0x000000000000000000000000000000000000000000000000000000000000087e",
-  "0x000000000000000000000000000000000000000000000000000000000000087f",
-  "0x0000000000000000000000000000000000000000000000000000000000000880",
-  "0x0000000000000000000000000000000000000000000000000000000000000881",
-  "0x0000000000000000000000000000000000000000000000000000000000000882",
-  "0x0000000000000000000000000000000000000000000000000000000000000883",
-  "0x0000000000000000000000000000000000000000000000000000000000000884",
-  "0x0000000000000000000000000000000000000000000000000000000000000885",
-  "0x0000000000000000000000000000000000000000000000000000000000000886",
-  "0x0000000000000000000000000000000000000000000000000000000000000887",
-  "0x0000000000000000000000000000000000000000000000000000000000000888",
-  "0x0000000000000000000000000000000000000000000000000000000000000889",
-  "0x000000000000000000000000000000000000000000000000000000000000088a",
-  "0x000000000000000000000000000000000000000000000000000000000000088b",
-  "0x000000000000000000000000000000000000000000000000000000000000088c",
-  "0x000000000000000000000000000000000000000000000000000000000000088d",
-  "0x000000000000000000000000000000000000000000000000000000000000088e",
-  "0x000000000000000000000000000000000000000000000000000000000000088f",
-  "0x0000000000000000000000000000000000000000000000000000000000000890",
-  "0x0000000000000000000000000000000000000000000000000000000000000891",
-  "0x0000000000000000000000000000000000000000000000000000000000000892",
-  "0x0000000000000000000000000000000000000000000000000000000000000893",
-  "0x0000000000000000000000000000000000000000000000000000000000000894",
-  "0x0000000000000000000000000000000000000000000000000000000000000895",
-  "0x0000000000000000000000000000000000000000000000000000000000000896",
-  "0x0000000000000000000000000000000000000000000000000000000000000897",
-  "0x0000000000000000000000000000000000000000000000000000000000000898",
-  "0x0000000000000000000000000000000000000000000000000000000000000899",
-  "0x000000000000000000000000000000000000000000000000000000000000089a",
-  "0x000000000000000000000000000000000000000000000000000000000000089b",
-  "0x000000000000000000000000000000000000000000000000000000000000089c",
-  "0x000000000000000000000000000000000000000000000000000000000000089d",
-  "0x000000000000000000000000000000000000000000000000000000000000089e",
-  "0x000000000000000000000000000000000000000000000000000000000000089f",
-  "0x00000000000000000000000000000000000000000000000000000000000008a0",
-  "0x00000000000000000000000000000000000000000000000000000000000008a1",
-  "0x00000000000000000000000000000000000000000000000000000000000008a2",
-  "0x00000000000000000000000000000000000000000000000000000000000008a3",
-  "0x00000000000000000000000000000000000000000000000000000000000008a4",
-  "0x00000000000000000000000000000000000000000000000000000000000008a5",
-  "0x00000000000000000000000000000000000000000000000000000000000008a6",
-  "0x00000000000000000000000000000000000000000000000000000000000008a7",
-  "0x00000000000000000000000000000000000000000000000000000000000008a8",
-  "0x00000000000000000000000000000000000000000000000000000000000008a9",
-  "0x00000000000000000000000000000000000000000000000000000000000008aa",
-  "0x00000000000000000000000000000000000000000000000000000000000008ab",
-  "0x00000000000000000000000000000000000000000000000000000000000008ac",
-  "0x00000000000000000000000000000000000000000000000000000000000008ad",
-  "0x00000000000000000000000000000000000000000000000000000000000008ae",
-  "0x00000000000000000000000000000000000000000000000000000000000008af",
-  "0x00000000000000000000000000000000000000000000000000000000000008b0",
-  "0x00000000000000000000000000000000000000000000000000000000000008b1",
-  "0x00000000000000000000000000000000000000000000000000000000000008b2",
-  "0x00000000000000000000000000000000000000000000000000000000000008b3",
-  "0x00000000000000000000000000000000000000000000000000000000000008b4",
-  "0x00000000000000000000000000000000000000000000000000000000000008b5",
-  "0x00000000000000000000000000000000000000000000000000000000000008b6",
-  "0x00000000000000000000000000000000000000000000000000000000000008b7",
-  "0x00000000000000000000000000000000000000000000000000000000000008b8",
-  "0x00000000000000000000000000000000000000000000000000000000000008b9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ba",
-  "0x00000000000000000000000000000000000000000000000000000000000008bb",
-  "0x00000000000000000000000000000000000000000000000000000000000008bc",
-  "0x00000000000000000000000000000000000000000000000000000000000008bd",
-  "0x00000000000000000000000000000000000000000000000000000000000008be",
-  "0x00000000000000000000000000000000000000000000000000000000000008bf",
-  "0x00000000000000000000000000000000000000000000000000000000000008c0",
-  "0x00000000000000000000000000000000000000000000000000000000000008c1",
-  "0x00000000000000000000000000000000000000000000000000000000000008c2",
-  "0x00000000000000000000000000000000000000000000000000000000000008c3",
-  "0x00000000000000000000000000000000000000000000000000000000000008c4",
-  "0x00000000000000000000000000000000000000000000000000000000000008c5",
-  "0x00000000000000000000000000000000000000000000000000000000000008c6",
-  "0x00000000000000000000000000000000000000000000000000000000000008c7",
-  "0x00000000000000000000000000000000000000000000000000000000000008c8",
-  "0x00000000000000000000000000000000000000000000000000000000000008c9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ca",
-  "0x00000000000000000000000000000000000000000000000000000000000008cb",
-  "0x00000000000000000000000000000000000000000000000000000000000008cc",
-  "0x00000000000000000000000000000000000000000000000000000000000008cd",
-  "0x00000000000000000000000000000000000000000000000000000000000008ce",
-  "0x00000000000000000000000000000000000000000000000000000000000008cf",
-  "0x00000000000000000000000000000000000000000000000000000000000008d0",
-  "0x00000000000000000000000000000000000000000000000000000000000008d1",
-  "0x00000000000000000000000000000000000000000000000000000000000008d2",
-  "0x00000000000000000000000000000000000000000000000000000000000008d3",
-  "0x00000000000000000000000000000000000000000000000000000000000008d4",
-  "0x00000000000000000000000000000000000000000000000000000000000008d5",
-  "0x00000000000000000000000000000000000000000000000000000000000008d6",
-  "0x00000000000000000000000000000000000000000000000000000000000008d7",
-  "0x00000000000000000000000000000000000000000000000000000000000008d8",
-  "0x00000000000000000000000000000000000000000000000000000000000008d9",
-  "0x00000000000000000000000000000000000000000000000000000000000008da",
-  "0x00000000000000000000000000000000000000000000000000000000000008db",
-  "0x00000000000000000000000000000000000000000000000000000000000008dc",
-  "0x00000000000000000000000000000000000000000000000000000000000008dd",
-  "0x00000000000000000000000000000000000000000000000000000000000008de",
-  "0x00000000000000000000000000000000000000000000000000000000000008df",
-  "0x00000000000000000000000000000000000000000000000000000000000008e0",
-  "0x00000000000000000000000000000000000000000000000000000000000008e1",
-  "0x00000000000000000000000000000000000000000000000000000000000008e2",
-  "0x00000000000000000000000000000000000000000000000000000000000008e3",
-  "0x00000000000000000000000000000000000000000000000000000000000008e4",
-  "0x00000000000000000000000000000000000000000000000000000000000008e5",
-  "0x00000000000000000000000000000000000000000000000000000000000008e6",
-  "0x00000000000000000000000000000000000000000000000000000000000008e7",
-  "0x00000000000000000000000000000000000000000000000000000000000008e8",
-  "0x00000000000000000000000000000000000000000000000000000000000008e9",
-  "0x00000000000000000000000000000000000000000000000000000000000008ea",
-  "0x00000000000000000000000000000000000000000000000000000000000008eb",
-  "0x00000000000000000000000000000000000000000000000000000000000008ec",
-  "0x00000000000000000000000000000000000000000000000000000000000008ed",
-  "0x00000000000000000000000000000000000000000000000000000000000008ee",
-  "0x00000000000000000000000000000000000000000000000000000000000008ef",
-  "0x00000000000000000000000000000000000000000000000000000000000008f0",
-  "0x00000000000000000000000000000000000000000000000000000000000008f1",
-  "0x00000000000000000000000000000000000000000000000000000000000008f2",
-  "0x00000000000000000000000000000000000000000000000000000000000008f3",
-  "0x00000000000000000000000000000000000000000000000000000000000008f4",
-  "0x00000000000000000000000000000000000000000000000000000000000008f5",
-  "0x00000000000000000000000000000000000000000000000000000000000008f6",
-  "0x00000000000000000000000000000000000000000000000000000000000008f7",
-  "0x00000000000000000000000000000000000000000000000000000000000008f8",
-  "0x00000000000000000000000000000000000000000000000000000000000008f9",
-  "0x00000000000000000000000000000000000000000000000000000000000008fa",
-  "0x00000000000000000000000000000000000000000000000000000000000008fb",
-  "0x00000000000000000000000000000000000000000000000000000000000008fc",
-  "0x00000000000000000000000000000000000000000000000000000000000008fd",
-  "0x00000000000000000000000000000000000000000000000000000000000008fe",
-  "0x00000000000000000000000000000000000000000000000000000000000008ff",
-  "0x0000000000000000000000000000000000000000000000000000000000000900",
-  "0x0000000000000000000000000000000000000000000000000000000000000901",
-  "0x0000000000000000000000000000000000000000000000000000000000000902",
-  "0x0000000000000000000000000000000000000000000000000000000000000903",
-  "0x0000000000000000000000000000000000000000000000000000000000000904",
-  "0x0000000000000000000000000000000000000000000000000000000000000905",
-  "0x0000000000000000000000000000000000000000000000000000000000000906",
-  "0x0000000000000000000000000000000000000000000000000000000000000907",
-  "0x0000000000000000000000000000000000000000000000000000000000000908",
-  "0x0000000000000000000000000000000000000000000000000000000000000909",
-  "0x000000000000000000000000000000000000000000000000000000000000090a",
-  "0x000000000000000000000000000000000000000000000000000000000000090b",
-  "0x000000000000000000000000000000000000000000000000000000000000090c",
-  "0x000000000000000000000000000000000000000000000000000000000000090d",
-  "0x000000000000000000000000000000000000000000000000000000000000090e",
-  "0x000000000000000000000000000000000000000000000000000000000000090f",
-  "0x0000000000000000000000000000000000000000000000000000000000000910",
-  "0x0000000000000000000000000000000000000000000000000000000000000911",
-  "0x0000000000000000000000000000000000000000000000000000000000000912",
-  "0x0000000000000000000000000000000000000000000000000000000000000913",
-  "0x0000000000000000000000000000000000000000000000000000000000000914",
-  "0x0000000000000000000000000000000000000000000000000000000000000915",
-  "0x0000000000000000000000000000000000000000000000000000000000000916",
-  "0x0000000000000000000000000000000000000000000000000000000000000917",
-  "0x0000000000000000000000000000000000000000000000000000000000000918",
-  "0x0000000000000000000000000000000000000000000000000000000000000919",
-  "0x000000000000000000000000000000000000000000000000000000000000091a",
-  "0x000000000000000000000000000000000000000000000000000000000000091b",
-  "0x000000000000000000000000000000000000000000000000000000000000091c",
-  "0x000000000000000000000000000000000000000000000000000000000000091d",
-  "0x000000000000000000000000000000000000000000000000000000000000091e",
-  "0x000000000000000000000000000000000000000000000000000000000000091f",
-  "0x0000000000000000000000000000000000000000000000000000000000000920",
-  "0x0000000000000000000000000000000000000000000000000000000000000921",
-  "0x0000000000000000000000000000000000000000000000000000000000000922",
-  "0x0000000000000000000000000000000000000000000000000000000000000923",
-  "0x0000000000000000000000000000000000000000000000000000000000000924",
-  "0x0000000000000000000000000000000000000000000000000000000000000925",
-  "0x0000000000000000000000000000000000000000000000000000000000000926",
-  "0x0000000000000000000000000000000000000000000000000000000000000927",
-  "0x0000000000000000000000000000000000000000000000000000000000000928",
-  "0x0000000000000000000000000000000000000000000000000000000000000929",
-  "0x000000000000000000000000000000000000000000000000000000000000092a",
-  "0x000000000000000000000000000000000000000000000000000000000000092b",
-  "0x000000000000000000000000000000000000000000000000000000000000092c",
-  "0x000000000000000000000000000000000000000000000000000000000000092d",
-  "0x000000000000000000000000000000000000000000000000000000000000092e",
-  "0x000000000000000000000000000000000000000000000000000000000000092f",
-  "0x0000000000000000000000000000000000000000000000000000000000000930",
-  "0x0000000000000000000000000000000000000000000000000000000000000931",
-  "0x0000000000000000000000000000000000000000000000000000000000000932",
-  "0x0000000000000000000000000000000000000000000000000000000000000933",
-  "0x0000000000000000000000000000000000000000000000000000000000000934",
-  "0x0000000000000000000000000000000000000000000000000000000000000935",
-  "0x0000000000000000000000000000000000000000000000000000000000000936",
-  "0x0000000000000000000000000000000000000000000000000000000000000937",
-  "0x0000000000000000000000000000000000000000000000000000000000000938",
-  "0x0000000000000000000000000000000000000000000000000000000000000939",
-  "0x000000000000000000000000000000000000000000000000000000000000093a",
-  "0x000000000000000000000000000000000000000000000000000000000000093b",
-  "0x000000000000000000000000000000000000000000000000000000000000093c",
-  "0x000000000000000000000000000000000000000000000000000000000000093d",
-  "0x000000000000000000000000000000000000000000000000000000000000093e",
-  "0x000000000000000000000000000000000000000000000000000000000000093f",
-  "0x0000000000000000000000000000000000000000000000000000000000000940",
-  "0x0000000000000000000000000000000000000000000000000000000000000941",
-  "0x0000000000000000000000000000000000000000000000000000000000000942",
-  "0x0000000000000000000000000000000000000000000000000000000000000943",
-  "0x0000000000000000000000000000000000000000000000000000000000000944",
-  "0x0000000000000000000000000000000000000000000000000000000000000945",
-  "0x0000000000000000000000000000000000000000000000000000000000000946",
-  "0x0000000000000000000000000000000000000000000000000000000000000947",
-  "0x0000000000000000000000000000000000000000000000000000000000000948",
-  "0x0000000000000000000000000000000000000000000000000000000000000949",
-  "0x000000000000000000000000000000000000000000000000000000000000094a",
-  "0x000000000000000000000000000000000000000000000000000000000000094b",
-  "0x000000000000000000000000000000000000000000000000000000000000094c",
-  "0x000000000000000000000000000000000000000000000000000000000000094d",
-  "0x000000000000000000000000000000000000000000000000000000000000094e",
-  "0x000000000000000000000000000000000000000000000000000000000000094f",
-  "0x0000000000000000000000000000000000000000000000000000000000000950",
-  "0x0000000000000000000000000000000000000000000000000000000000000951",
-  "0x0000000000000000000000000000000000000000000000000000000000000952",
-  "0x0000000000000000000000000000000000000000000000000000000000000953",
-  "0x0000000000000000000000000000000000000000000000000000000000000954",
-  "0x0000000000000000000000000000000000000000000000000000000000000955",
-  "0x0000000000000000000000000000000000000000000000000000000000000956",
-  "0x0000000000000000000000000000000000000000000000000000000000000957",
-  "0x0000000000000000000000000000000000000000000000000000000000000958",
-  "0x0000000000000000000000000000000000000000000000000000000000000959",
-  "0x000000000000000000000000000000000000000000000000000000000000095a",
-  "0x000000000000000000000000000000000000000000000000000000000000095b",
-  "0x000000000000000000000000000000000000000000000000000000000000095c",
-  "0x000000000000000000000000000000000000000000000000000000000000095d",
-  "0x000000000000000000000000000000000000000000000000000000000000095e",
-  "0x000000000000000000000000000000000000000000000000000000000000095f",
-  "0x0000000000000000000000000000000000000000000000000000000000000960",
-  "0x0000000000000000000000000000000000000000000000000000000000000961",
-  "0x0000000000000000000000000000000000000000000000000000000000000962",
-  "0x0000000000000000000000000000000000000000000000000000000000000963",
-  "0x0000000000000000000000000000000000000000000000000000000000000964",
-  "0x0000000000000000000000000000000000000000000000000000000000000965",
-  "0x0000000000000000000000000000000000000000000000000000000000000966",
-  "0x0000000000000000000000000000000000000000000000000000000000000967",
-  "0x0000000000000000000000000000000000000000000000000000000000000968",
-  "0x0000000000000000000000000000000000000000000000000000000000000969",
-  "0x000000000000000000000000000000000000000000000000000000000000096a",
-  "0x000000000000000000000000000000000000000000000000000000000000096b",
-  "0x000000000000000000000000000000000000000000000000000000000000096c",
-  "0x000000000000000000000000000000000000000000000000000000000000096d",
-  "0x000000000000000000000000000000000000000000000000000000000000096e",
-  "0x000000000000000000000000000000000000000000000000000000000000096f",
-  "0x0000000000000000000000000000000000000000000000000000000000000970",
-  "0x0000000000000000000000000000000000000000000000000000000000000971",
-  "0x0000000000000000000000000000000000000000000000000000000000000972",
-  "0x0000000000000000000000000000000000000000000000000000000000000973",
-  "0x0000000000000000000000000000000000000000000000000000000000000974",
-  "0x0000000000000000000000000000000000000000000000000000000000000975",
-  "0x0000000000000000000000000000000000000000000000000000000000000976",
-  "0x0000000000000000000000000000000000000000000000000000000000000977",
-  "0x0000000000000000000000000000000000000000000000000000000000000978",
-  "0x0000000000000000000000000000000000000000000000000000000000000979",
-  "0x000000000000000000000000000000000000000000000000000000000000097a",
-  "0x000000000000000000000000000000000000000000000000000000000000097b",
-  "0x000000000000000000000000000000000000000000000000000000000000097c",
-  "0x000000000000000000000000000000000000000000000000000000000000097d",
-  "0x000000000000000000000000000000000000000000000000000000000000097e",
-  "0x000000000000000000000000000000000000000000000000000000000000097f",
-  "0x0000000000000000000000000000000000000000000000000000000000000980",
-  "0x0000000000000000000000000000000000000000000000000000000000000981",
-  "0x0000000000000000000000000000000000000000000000000000000000000982",
-  "0x0000000000000000000000000000000000000000000000000000000000000983",
-  "0x0000000000000000000000000000000000000000000000000000000000000984",
-  "0x0000000000000000000000000000000000000000000000000000000000000985",
-  "0x0000000000000000000000000000000000000000000000000000000000000986",
-  "0x0000000000000000000000000000000000000000000000000000000000000987",
-  "0x0000000000000000000000000000000000000000000000000000000000000988",
-  "0x0000000000000000000000000000000000000000000000000000000000000989",
-  "0x000000000000000000000000000000000000000000000000000000000000098a",
-  "0x000000000000000000000000000000000000000000000000000000000000098b",
-  "0x000000000000000000000000000000000000000000000000000000000000098c",
-  "0x000000000000000000000000000000000000000000000000000000000000098d",
-  "0x000000000000000000000000000000000000000000000000000000000000098e",
-  "0x000000000000000000000000000000000000000000000000000000000000098f",
-  "0x0000000000000000000000000000000000000000000000000000000000000990",
-  "0x0000000000000000000000000000000000000000000000000000000000000991",
-  "0x0000000000000000000000000000000000000000000000000000000000000992",
-  "0x0000000000000000000000000000000000000000000000000000000000000993",
-  "0x0000000000000000000000000000000000000000000000000000000000000994",
-  "0x0000000000000000000000000000000000000000000000000000000000000995",
-  "0x0000000000000000000000000000000000000000000000000000000000000996",
-  "0x0000000000000000000000000000000000000000000000000000000000000997",
-  "0x0000000000000000000000000000000000000000000000000000000000000998",
-  "0x0000000000000000000000000000000000000000000000000000000000000999",
-  "0x000000000000000000000000000000000000000000000000000000000000099a",
-  "0x000000000000000000000000000000000000000000000000000000000000099b",
-  "0x000000000000000000000000000000000000000000000000000000000000099c",
-  "0x000000000000000000000000000000000000000000000000000000000000099d",
-  "0x000000000000000000000000000000000000000000000000000000000000099e",
-  "0x000000000000000000000000000000000000000000000000000000000000099f",
-  "0x00000000000000000000000000000000000000000000000000000000000009a0",
-  "0x00000000000000000000000000000000000000000000000000000000000009a1",
-  "0x00000000000000000000000000000000000000000000000000000000000009a2",
-  "0x00000000000000000000000000000000000000000000000000000000000009a3",
-  "0x00000000000000000000000000000000000000000000000000000000000009a4",
-  "0x00000000000000000000000000000000000000000000000000000000000009a5",
-  "0x00000000000000000000000000000000000000000000000000000000000009a6",
-  "0x00000000000000000000000000000000000000000000000000000000000009a7",
-  "0x00000000000000000000000000000000000000000000000000000000000009a8",
-  "0x00000000000000000000000000000000000000000000000000000000000009a9",
-  "0x00000000000000000000000000000000000000000000000000000000000009aa",
-  "0x00000000000000000000000000000000000000000000000000000000000009ab",
-  "0x00000000000000000000000000000000000000000000000000000000000009ac",
-  "0x00000000000000000000000000000000000000000000000000000000000009ad",
-  "0x00000000000000000000000000000000000000000000000000000000000009ae",
-  "0x00000000000000000000000000000000000000000000000000000000000009af",
-  "0x00000000000000000000000000000000000000000000000000000000000009b0",
-  "0x00000000000000000000000000000000000000000000000000000000000009b1",
-  "0x00000000000000000000000000000000000000000000000000000000000009b2",
-  "0x00000000000000000000000000000000000000000000000000000000000009b3",
-  "0x00000000000000000000000000000000000000000000000000000000000009b4",
-  "0x00000000000000000000000000000000000000000000000000000000000009b5",
-  "0x00000000000000000000000000000000000000000000000000000000000009b6",
-  "0x00000000000000000000000000000000000000000000000000000000000009b7",
-  "0x00000000000000000000000000000000000000000000000000000000000009b8",
-  "0x00000000000000000000000000000000000000000000000000000000000009b9",
-  "0x00000000000000000000000000000000000000000000000000000000000009ba",
-  "0x00000000000000000000000000000000000000000000000000000000000009bb",
-  "0x00000000000000000000000000000000000000000000000000000000000009bc",
-  "0x00000000000000000000000000000000000000000000000000000000000009bd",
-  "0x00000000000000000000000000000000000000000000000000000000000009be",
-  "0x00000000000000000000000000000000000000000000000000000000000009bf",
-  "0x00000000000000000000000000000000000000000000000000000000000009c0",
-  "0x00000000000000000000000000000000000000000000000000000000000009c1",
-  "0x00000000000000000000000000000000000000000000000000000000000009c2",
-  "0x00000000000000000000000000000000000000000000000000000000000009c3",
-  "0x00000000000000000000000000000000000000000000000000000000000009c4",
-  "0x00000000000000000000000000000000000000000000000000000000000009c5",
-  "0x00000000000000000000000000000000000000000000000000000000000009c6",
-  "0x00000000000000000000000000000000000000000000000000000000000009c7",
-  "0x00000000000000000000000000000000000000000000000000000000000009c8",
-  "0x00000000000000000000000000000000000000000000000000000000000009c9",
-  "0x00000000000000000000000000000000000000000000000000000000000009ca",
-  "0x00000000000000000000000000000000000000000000000000000000000009cb",
-  "0x00000000000000000000000000000000000000000000000000000000000009cc",
-  "0x00000000000000000000000000000000000000000000000000000000000009cd",
-  "0x00000000000000000000000000000000000000000000000000000000000009ce",
-  "0x00000000000000000000000000000000000000000000000000000000000009cf",
-  "0x00000000000000000000000000000000000000000000000000000000000009d0",
-  "0x00000000000000000000000000000000000000000000000000000000000009d1",
-  "0x00000000000000000000000000000000000000000000000000000000000009d2",
-  "0x00000000000000000000000000000000000000000000000000000000000009d3",
-  "0x00000000000000000000000000000000000000000000000000000000000009d4",
-  "0x00000000000000000000000000000000000000000000000000000000000009d5",
-  "0x00000000000000000000000000000000000000000000000000000000000009d6",
-  "0x00000000000000000000000000000000000000000000000000000000000009d7",
-  "0x00000000000000000000000000000000000000000000000000000000000009d8",
-  "0x00000000000000000000000000000000000000000000000000000000000009d9",
-  "0x00000000000000000000000000000000000000000000000000000000000009da",
-  "0x00000000000000000000000000000000000000000000000000000000000009db"
+  "0x00000000000000000000000000000000000000000000000000000000000006db"
 ]
-  num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400"
-  num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400"
+  num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
   [inputs.previous_l1_to_l2]
   root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a"
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml
index 6ff6bca8bbe4..80d3125a74bb 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml
@@ -1,16 +1,16 @@
 [inputs]
 l1_to_l2_message_frontier_hint = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x2c7fea674d2d40f18ffc3f161020dcd660472023bdc7774ae7cdf7b250153f4d",
+  "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb",
+  "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d",
+  "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037",
+  "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da",
+  "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249",
+  "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f",
+  "0x221cf368938c74e4fced9dfb2a8e37cd8a6c57d21385c249f0b5c2412341287f",
+  "0x28de0afc3b7c36426727790810acf92fb799c6ad75ea95773df7373ffa47a2d5",
+  "0x13abc9bba431e6930c169f5daeb60aedbb27d7618c7ff88b3b4ec1c6de1d6bb8",
+  "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f",
   "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad",
   "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da",
   "0x1077e8e59029b12e321c47a8a2a25283e50664b6ca1dd766a83828ddc6a22bb9",
@@ -39,7 +39,7 @@ l1_to_l2_message_frontier_hint = [
 ]
 new_archive_sibling_path = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x2f559d93de6d3e8a6289d45995351f749463bcee0ee677456f8ee19347c27114",
+  "0x09ced185017484542cc516a7c39025c309435391392f20f2c2589b73fdf98beb",
   "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d",
   "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037",
   "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da",
@@ -561,17 +561,17 @@ new_archive_sibling_path = [
     accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
       [inputs.previous_rollup.public_inputs.constants]
-      vk_tree_root = "0x1d51e7bb66dda198c072b182a8e4809fc6614d677c914af2afa9c5376f16f06d"
+      vk_tree_root = "0x1d366660277d0da1e9c56a961b6d5b5cac2b74641eba14de96aff4f319db5556"
       protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b"
       prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
         [inputs.previous_rollup.public_inputs.constants.last_archive]
-        root = "0x0c2eb70ed9c405d7895991207fcf58411017ab8481fba43c23b8d01f9ee6d826"
+        root = "0x16c0e54e365b3ef491ec8674385011aa8423f7098cd2e31a7e38418cd566954c"
         next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002"
 
         [inputs.previous_rollup.public_inputs.constants.l1_to_l2_tree_snapshot]
-        root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+        root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
         [inputs.previous_rollup.public_inputs.constants.global_variables]
         chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
@@ -621,13 +621,13 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
         cache = [
   "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684",
   "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9",
-  "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
+  "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
 ]
         state = [
-  "0x1e20e5a8cee556f890f804b4c34dfa9d0c0691184ef311d07a3360c7a3ed0abb",
-  "0x2f58f461552b8e4a5eb0e2390a113ced8ed4fbe200eae42042548cc471aa8302",
-  "0x0f289d4b3c928a76f3d6b02eb37d55a0bc9f5efe83f048e9bb6087c97ecd2629",
-  "0x030aab4986f4fd9cf6184c20046212db4094a9884e02d5fd5cb39b8c3fa73119"
+  "0x296688caf8c675edec6612bc58b5f43e1305214de989f5a2f986699c7826c19d",
+  "0x0dbc9b2cbdfc5dd7384fb3c3b80594069b636e8662947ba0530c59ca5cb8d39d",
+  "0x145c7ec32e665df9b71fb304e582c080166574d7670819f401e7617ba9943c77",
+  "0x28517588880808426fb3bd151a52566ae7e9003201a1fef074a2a57884386fc8"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003"
         squeeze_mode = false
@@ -642,10 +642,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b7e5c34c"
 ]
         state = [
-  "0x03a9c278ef420de34c98d3ed9353652c050aa787564e29869ba130c93aeeb58c",
-  "0x04840897fb96b980247599b309da2659be7d79a529b8e120a3de7d0ce81a18c4",
-  "0x261c3adfec1a9c39f94e54687fc959511aa357d07907d7eb60b6c1ede39dc9f8",
-  "0x22aeae6b14550f3d8954f9f9098c4255a25eabe1d0e5e6c662a8917c3d1a0e00"
+  "0x03f5bb77b4d38e2ebfdbbe3b9bf38ad342e8f3ee8caa0100794e01f44f37c5c5",
+  "0x20adca6aa6874004b8a341f1fc0f1c88f728f57cbf0f0bb4bb07b6e9e5437f3f",
+  "0x2e8f10bebcec3c76c071c400803ee281460e398e3ac3608ea102be3270d3911b",
+  "0x1269d3e85fd4404c79a5a57c78642522332ab5ae3b8f424fdeed7c5777349268"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002"
         squeeze_mode = false
@@ -654,12 +654,12 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
     leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000008"
     sibling_path = [
   "0x10b6730f1d1e9c6bf8d7c4b42b64b40d2603e3ae6ddbd464c3d8fcfb9e06e6d4",
-  "0x014ffec160e37b6cb713c1a4e6e7058964dde1733e6734520ed72f72fd262919",
-  "0x14bb1983f28c88ab603e0fe7e46b743829816df364ec385e2245072c3dad3e1e",
+  "0x171bffeec1260bb9f698111c91ca858d65feda265f392e620d474cb0cd818d11",
+  "0x16be345917fc7e9b43ef91c1e90e4aad1966337808cf67897c58f7a77a81f907",
   "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd",
   "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d",
   "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41",
-  "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd"
+  "0x0a082458fe660d17b7c5348e39012f798c9805cc616347c76862995fb24394e9"
 ]
 
       [inputs.previous_rollup.vk_data.vk]
@@ -1039,797 +1039,28 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000"
 ]
   num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000"
-  num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
   [inputs.previous_l1_to_l2]
-  root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-  next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+  root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+  next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
   [inputs.start_msg_sponge]
-  num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400"
+  num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
     [inputs.start_msg_sponge.sponge]
     cache = [
-  "0x00000000000000000000000000000000000000000000000000000000000009db",
-  "0x00000000000000000000000000000000000000000000000000000000000009d9",
-  "0x00000000000000000000000000000000000000000000000000000000000009da"
+  "0x00000000000000000000000000000000000000000000000000000000000006db",
+  "0x00000000000000000000000000000000000000000000000000000000000006d9",
+  "0x00000000000000000000000000000000000000000000000000000000000006da"
 ]
     state = [
-  "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6",
-  "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf",
-  "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918",
-  "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0"
+  "0x0a0aa9eae5277bc3a8414be4a1a279d69f89d765ed17a0123ac83a2547a9cf99",
+  "0x22e19d5ba8ed0525429b7ac6b29abd221ed25181a9a2085507125e57ad7c3514",
+  "0x29f22a3e1d331fa7d7d47f6f0f139d765279266c338b405db43ecd66b5ef328c",
+  "0x1235e52a8b15fc46edb612d48c23715f76bba8eb563b9e29e2519f16612f0faa"
 ]
     cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001"
     squeeze_mode = false
diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml
index 4d66dba58d6a..6b7d46511122 100644
--- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml
+++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml
@@ -1,16 +1,16 @@
 [inputs]
 l1_to_l2_message_frontier_hint = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x2c7fea674d2d40f18ffc3f161020dcd660472023bdc7774ae7cdf7b250153f4d",
+  "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb",
+  "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d",
+  "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037",
+  "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da",
+  "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249",
+  "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f",
+  "0x221cf368938c74e4fced9dfb2a8e37cd8a6c57d21385c249f0b5c2412341287f",
+  "0x28de0afc3b7c36426727790810acf92fb799c6ad75ea95773df7373ffa47a2d5",
+  "0x13abc9bba431e6930c169f5daeb60aedbb27d7618c7ff88b3b4ec1c6de1d6bb8",
+  "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f",
   "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad",
   "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da",
   "0x1077e8e59029b12e321c47a8a2a25283e50664b6ca1dd766a83828ddc6a22bb9",
@@ -39,7 +39,7 @@ l1_to_l2_message_frontier_hint = [
 ]
 new_archive_sibling_path = [
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x284d753011a1544ea66ccc1024bcc2aef83468522f0151d20454f31a06424e77",
+  "0x246e054b618bfe3dba53a868a15e03580e6b33f98276a8c4c47b51ec4d75f91a",
   "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d",
   "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037",
   "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da",
@@ -561,17 +561,17 @@ new_archive_sibling_path = [
     accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0"
 
       [inputs.previous_rollups.public_inputs.constants]
-      vk_tree_root = "0x1d51e7bb66dda198c072b182a8e4809fc6614d677c914af2afa9c5376f16f06d"
+      vk_tree_root = "0x1d366660277d0da1e9c56a961b6d5b5cac2b74641eba14de96aff4f319db5556"
       protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b"
       prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
         [inputs.previous_rollups.public_inputs.constants.last_archive]
-        root = "0x22fb435f1b17b06f994e96f8b9092935bb52d7ff089f9da911deb76fb11eafd0"
+        root = "0x17e342833e9a503e487d0585aaa811413b9e97e799b6380f11ef87739a9c51c6"
         next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002"
 
         [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot]
-        root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+        root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
         [inputs.previous_rollups.public_inputs.constants.global_variables]
         chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
@@ -620,14 +620,14 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
         [inputs.previous_rollups.public_inputs.start_sponge_blob.sponge]
         cache = [
   "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759",
-  "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b",
+  "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c",
   "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00"
 ]
         state = [
-  "0x2a5cf7199bc1a5f8871b4fea5c6f99f5dba43db93b819ca26d2fa8dbbdc1f82c",
-  "0x011cf649f43e718babd7d68caa9d36ccebf49e536e764b6674fc8ca18e8a4ada",
-  "0x17d68b99d3347b9908ca791c2a098777db49c111ac24b850a48e36fd0329b4e4",
-  "0x038347b13467b09e427b9f4154c2d36b1cd02bd1b08d8ea406687512f0b16a79"
+  "0x0ed34d05d9f9202133d5c92c46e4ac7513e31af888e26a97b58cc2d915d05b3b",
+  "0x1b8afba07fbbd85c25ead91c2dd7cedc2ec9e3b8fd78015ffa3364f65be85754",
+  "0x1d48d161d1b58223944fd9aff7785262435d1186e0f48763af9e6fded07180a4",
+  "0x22be79b49f02e95e4e01f2be9233193843d0f5bf74a42ab613acae94d7f08821"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002"
         squeeze_mode = false
@@ -642,10 +642,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b7f9d44d"
 ]
         state = [
-  "0x2d2cd78abcdb723be782846e1ad64ae3ab9aa2260689da6ae7475677befc11c2",
-  "0x0250e73c2089d502af086b4d31fc90a61b62f71901e93588a19421c1e54417db",
-  "0x1225c74c7caef02691c6f3a18a18ed4ce10675ec8286339594bef2cee3bcdf01",
-  "0x0b9145803dfcf3b0958502feb867fdbb62eb5726361b0971f704ffe19719c0af"
+  "0x281dc2e83dae7232811dba0138c8f131770932a18414df83b0d02752279847db",
+  "0x0bacc1f834da52486c08c6dd68531d826a8d5d2cf5b698794325b2c4fe926804",
+  "0x2c1585f2e23007495bfc7fb7c32aa2320d0d3fa9e793c21b8d9cb4482c570f58",
+  "0x03f837a0ecdc625e6669fa6685617a7b9fa02f8036411be51f9cc857192e8cc4"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001"
         squeeze_mode = false
@@ -656,10 +656,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x1fc39d0a428c8536dbca551ea79848acf67d89d090fd8c643c7d90f2e8f32340",
   "0x12ce5a49a1ceca53ada7bee003f929bbd65abaa74e8072a81f304c2c96c44e31",
   "0x2dd71474f7775d87b6c2986ace5f654686583f0970d7400b1ccf8096dad131b5",
-  "0x1bd9ea476112f37bb5ce44ce3c3f0d2e62e20993253269166a016eda81ac1007",
+  "0x22fe3deda3c756121ae860fd950eef8dc76c6e4db472e345da469025560db9d8",
   "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d",
   "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41",
-  "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd"
+  "0x0a082458fe660d17b7c5348e39012f798c9805cc616347c76862995fb24394e9"
 ]
 
       [inputs.previous_rollups.vk_data.vk]
@@ -1273,17 +1273,17 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
     accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
       [inputs.previous_rollups.public_inputs.constants]
-      vk_tree_root = "0x1d51e7bb66dda198c072b182a8e4809fc6614d677c914af2afa9c5376f16f06d"
+      vk_tree_root = "0x1d366660277d0da1e9c56a961b6d5b5cac2b74641eba14de96aff4f319db5556"
       protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b"
       prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
         [inputs.previous_rollups.public_inputs.constants.last_archive]
-        root = "0x22fb435f1b17b06f994e96f8b9092935bb52d7ff089f9da911deb76fb11eafd0"
+        root = "0x17e342833e9a503e487d0585aaa811413b9e97e799b6380f11ef87739a9c51c6"
         next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002"
 
         [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot]
-        root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+        root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+        next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
         [inputs.previous_rollups.public_inputs.constants.global_variables]
         chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000"
@@ -1336,10 +1336,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b7f9d44d"
 ]
         state = [
-  "0x2d2cd78abcdb723be782846e1ad64ae3ab9aa2260689da6ae7475677befc11c2",
-  "0x0250e73c2089d502af086b4d31fc90a61b62f71901e93588a19421c1e54417db",
-  "0x1225c74c7caef02691c6f3a18a18ed4ce10675ec8286339594bef2cee3bcdf01",
-  "0x0b9145803dfcf3b0958502feb867fdbb62eb5726361b0971f704ffe19719c0af"
+  "0x281dc2e83dae7232811dba0138c8f131770932a18414df83b0d02752279847db",
+  "0x0bacc1f834da52486c08c6dd68531d826a8d5d2cf5b698794325b2c4fe926804",
+  "0x2c1585f2e23007495bfc7fb7c32aa2320d0d3fa9e793c21b8d9cb4482c570f58",
+  "0x03f837a0ecdc625e6669fa6685617a7b9fa02f8036411be51f9cc857192e8cc4"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001"
         squeeze_mode = false
@@ -1354,10 +1354,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x00000000000000000000000000000000000000000000000000000000b80de34e"
 ]
         state = [
-  "0x081ffd41f516611101fabed22dbbba6e6bf5ac0eff43aa020fb8407fe66471be",
-  "0x07e1027927852cc3291b4d5b979823dfacab903c13b5bd3f2590388210b608ed",
-  "0x17c059bfe7dca4a328bf27482e1c7d33887c0ff69b69f2be89eb754266e263ed",
-  "0x1e85bde3c04a4baa1d2d6e1237d10ced927e777bbd7fa7c31fce28cdd79b92ca"
+  "0x1fc7df291bfa906a8b806cca48ff83bb2189e02359547ce167cd6b04362006cc",
+  "0x081a19d1eeca71317d8a8d1eca1f937f964098632f05539e35ebe1f1bb76d77a",
+  "0x1d34ac1e690b8e8c22be1900e47925f999aa9299dd545d3a925e0ced39a42e2f",
+  "0x2d57f014b4dec7f716fcd506d5af320576b1d738f62360797ccad70e338bd45c"
 ]
         cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003"
         squeeze_mode = false
@@ -1366,12 +1366,12 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
     leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000008"
     sibling_path = [
   "0x10b6730f1d1e9c6bf8d7c4b42b64b40d2603e3ae6ddbd464c3d8fcfb9e06e6d4",
-  "0x014ffec160e37b6cb713c1a4e6e7058964dde1733e6734520ed72f72fd262919",
-  "0x14bb1983f28c88ab603e0fe7e46b743829816df364ec385e2245072c3dad3e1e",
+  "0x171bffeec1260bb9f698111c91ca858d65feda265f392e620d474cb0cd818d11",
+  "0x16be345917fc7e9b43ef91c1e90e4aad1966337808cf67897c58f7a77a81f907",
   "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd",
   "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d",
   "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41",
-  "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd"
+  "0x0a082458fe660d17b7c5348e39012f798c9805cc616347c76862995fb24394e9"
 ]
 
       [inputs.previous_rollups.vk_data.vk]
@@ -1751,797 +1751,28 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000
   "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "0x0000000000000000000000000000000000000000000000000000000000000000",
   "0x0000000000000000000000000000000000000000000000000000000000000000"
 ]
   num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000"
-  num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
   [inputs.previous_l1_to_l2]
-  root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b"
-  next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400"
+  root = "0x0c123047b777079e8db5f669ddaf1ffa1c7780d56b21e29f35e4772ac0f6280c"
+  next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
   [inputs.start_msg_sponge]
-  num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400"
+  num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000100"
 
     [inputs.start_msg_sponge.sponge]
     cache = [
-  "0x00000000000000000000000000000000000000000000000000000000000009db",
-  "0x00000000000000000000000000000000000000000000000000000000000009d9",
-  "0x00000000000000000000000000000000000000000000000000000000000009da"
+  "0x00000000000000000000000000000000000000000000000000000000000006db",
+  "0x00000000000000000000000000000000000000000000000000000000000006d9",
+  "0x00000000000000000000000000000000000000000000000000000000000006da"
 ]
     state = [
-  "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6",
-  "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf",
-  "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918",
-  "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0"
+  "0x0a0aa9eae5277bc3a8414be4a1a279d69f89d765ed17a0123ac83a2547a9cf99",
+  "0x22e19d5ba8ed0525429b7ac6b29abd221ed25181a9a2085507125e57ad7c3514",
+  "0x29f22a3e1d331fa7d7d47f6f0f139d765279266c338b405db43ecd66b5ef328c",
+  "0x1235e52a8b15fc46edb612d48c23715f76bba8eb563b9e29e2519f16612f0faa"
 ]
     cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001"
     squeeze_mode = false

From a605bebb7c62e0bb06b72ace8106f0eb837861fe Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 17:27:30 -0300
Subject: [PATCH 20/22] test(fast-inbox): streaming inbox mocks for the
 validator and prover-node unit suites (A-1384)

With streaming as the only consumption path, the validator proposal handler and the prover node derive
consumed messages from L1-to-L2 tree leaf counts and the proposal bucket reference. Give the mocked block
headers a leaf count, carry a genesis-bucket reference on test proposals, and resolve bucket queries to the
genesis bucket so the acceptance checks pass with an empty bundle.
---
 .../prover-node/src/prover-node.test.ts       | 18 ++++++++----
 .../validator-client/src/validator.test.ts    | 29 +++++++++++++++++--
 2 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/yarn-project/prover-node/src/prover-node.test.ts b/yarn-project/prover-node/src/prover-node.test.ts
index 1c6729e6d801..cd9adc4a2b66 100644
--- a/yarn-project/prover-node/src/prover-node.test.ts
+++ b/yarn-project/prover-node/src/prover-node.test.ts
@@ -173,7 +173,7 @@ describe('ProverNode', () => {
     // getBlockData also feeds collectRegisterData when the rebuild re-registers, so it carries a header too.
     l2BlockSource.getBlockData.mockResolvedValue({
       checkpointNumber: CheckpointNumber(2),
-      header: { lastArchive: { root: Fr.ZERO } },
+      header: { lastArchive: { root: Fr.ZERO }, state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 0 } } },
     } as any);
     await proverNode.handleBlockStreamEvent({
       type: 'chain-pruned',
@@ -639,9 +639,9 @@ describe('ProverNode', () => {
     l2BlockSource.getBlockNumber.mockResolvedValue(undefined);
     setupRegistrationSuccess();
     // getBlockData returns a header that lets isEpochFullyProven bail out as "not proven"
-    // and supplies a lastArchive.root for collectRegisterData.
+    // and supplies a lastArchive.root plus an L1-to-L2 leaf count for collectRegisterData.
     l2BlockSource.getBlockData.mockResolvedValue({
-      header: { lastArchive: { root: Fr.ZERO } },
+      header: { lastArchive: { root: Fr.ZERO }, state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 0 } } },
     } as any);
   }
 
@@ -655,7 +655,7 @@ describe('ProverNode', () => {
     worldState.syncImmediate.mockResolvedValue(undefined as any);
     l1ToL2MessageSource.getL1ToL2Messages.mockResolvedValue([]);
     l2BlockSource.getBlockData.mockResolvedValue({
-      header: { lastArchive: { root: Fr.ZERO } },
+      header: { lastArchive: { root: Fr.ZERO }, state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 0 } } },
     } as any);
     worldState.getSnapshot.mockReturnValue({
       getTreeInfo: () => Promise.resolve({ size: 1n }),
@@ -673,7 +673,15 @@ describe('ProverNode', () => {
       number: CheckpointNumber(checkpointNumber),
       header: { slotNumber: SlotNumber(slot), inboxRollingHash: Fr.ZERO },
       archive: { root: archiveRoot },
-      blocks: [{ number: blockNumber, header: { hash: () => Promise.resolve('0x01') } }],
+      blocks: [
+        {
+          number: blockNumber,
+          header: {
+            hash: () => Promise.resolve('0x01'),
+            state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 0 } },
+          },
+        },
+      ],
       hash: () => new Fr(checkpointNumber),
     } as unknown as Checkpoint;
   }
diff --git a/yarn-project/validator-client/src/validator.test.ts b/yarn-project/validator-client/src/validator.test.ts
index ac8852427036..6adca5bd39c0 100644
--- a/yarn-project/validator-client/src/validator.test.ts
+++ b/yarn-project/validator-client/src/validator.test.ts
@@ -32,7 +32,12 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type BlockData, BlockHash, L2Block, type L2BlockSink, type L2BlockSource } from '@aztec/stdlib/block';
 import { type Checkpoint, CheckpointReexecutionTracker, type ProposedCheckpointData } from '@aztec/stdlib/checkpoint';
 import type { SlasherConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import {
+  type InboxBucket,
+  InboxBucketRef,
+  type L1ToL2MessageSource,
+  computeInHashFromL1ToL2Messages,
+} from '@aztec/stdlib/messaging';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import {
@@ -448,11 +453,24 @@ describe('ValidatorClient', () => {
           Array.isArray(args) &&
           args[0]?.offenseType === OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL,
       );
+    // AZIP-22 Fast Inbox: an empty-consumption streaming setup. Proposals reference the genesis Inbox bucket, the
+    // parent block's L1-to-L2 leaf count equals its cumulative total (0), so the derived per-block bundle is empty.
+    const genesisInboxBucket: InboxBucket = {
+      seq: 0n,
+      inboxRollingHash: Fr.ZERO,
+      totalMsgCount: 0n,
+      timestamp: 0n,
+      msgCount: 0,
+      lastMessageIndex: 0n,
+      isOpen: false,
+    };
+    const genesisBucketRef = InboxBucketRef.fromBucket(genesisInboxBucket);
+
     beforeEach(async () => {
       const emptyInHash = computeInHashFromL1ToL2Messages([]);
       const blockHeader = makeBlockHeader(1, { blockNumber: BlockNumber(100), slotNumber: SlotNumber(100) });
       blockNumber = BlockNumber(blockHeader.globalVariables.blockNumber);
-      proposal = await makeBlockProposal({ blockHeader, inHash: emptyInHash });
+      proposal = await makeBlockProposal({ blockHeader, inHash: emptyInHash, bucketRef: genesisBucketRef });
       // The proposal targets slot 100, which under pipelining is built during the previous slot. Set the
       // wall clock to the start of that build slot (target_slot_start - S), matching how a pipelined
       // proposer is positioned when validating an inbound block proposal. With S - 2E = 0 in this config
@@ -512,6 +530,7 @@ describe('ValidatorClient', () => {
           getBlockNumber: () => blockNumber - 1,
           getSlot: () => parentSlot,
           globalVariables: blockHeader.globalVariables,
+          state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 0 } },
         },
         archive: new AppendOnlyTreeSnapshot(Fr.random(), blockNumber - 1),
         blockHash: BlockHash.random(),
@@ -525,6 +544,11 @@ describe('ValidatorClient', () => {
       blockSource.getGenesisValues.mockResolvedValue({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
       blockSource.syncImmediate.mockImplementation(() => Promise.resolve());
 
+      // Resolve every Inbox bucket query to the genesis bucket, so streaming checks accept with an empty bundle.
+      l1ToL2MessageSource.getInboxBucket.mockResolvedValue(genesisInboxBucket);
+      l1ToL2MessageSource.getInboxBucketByTotalMsgCount.mockResolvedValue(genesisInboxBucket);
+      l1ToL2MessageSource.getL1ToL2MessagesBetweenBuckets.mockResolvedValue([]);
+
       const clonedBlockHeader = blockHeader.clone();
       blockBuildResult = {
         publicProcessorDuration: 0,
@@ -727,6 +751,7 @@ describe('ValidatorClient', () => {
         archiveRoot: proposal.archive,
         txHashes: proposal.txHashes,
         signer: selfSigner,
+        bucketRef: genesisBucketRef,
       });
 
       epochCache.getProposerAttesterAddressInSlot.mockResolvedValue(selfSigner.address);

From 4c6d86bb1bdddbdc0db97407f259efbea0377391 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 17:44:51 -0300
Subject: [PATCH 21/22] fix(fast-inbox): split epoch-proof functions into
 EpochProofExtLib to stay deployable (A-1384)

The streaming inbox consumption validation in ProposeLib pushed RollupOperationsExtLib past the EIP-170
deployable size limit (25470 > 24576), failing every real deployment (test_rollup_upgrade.sh). Move
submitEpochRootProof and getEpochProofPublicInputs into a new EpochProofExtLib external library, leaving
both libraries with comfortable margins (19296 and 13440 bytes).
---
 l1-contracts/src/core/Rollup.sol              |  3 +-
 l1-contracts/src/core/RollupCore.sol          |  3 +-
 .../libraries/rollup/EpochProofExtLib.sol     | 36 +++++++++++++++++++
 .../rollup/RollupOperationsExtLib.sol         | 25 +++----------
 4 files changed, 44 insertions(+), 23 deletions(-)
 create mode 100644 l1-contracts/src/core/libraries/rollup/EpochProofExtLib.sol

diff --git a/l1-contracts/src/core/Rollup.sol b/l1-contracts/src/core/Rollup.sol
index 9d4cb1a17f10..3abd82078875 100644
--- a/l1-contracts/src/core/Rollup.sol
+++ b/l1-contracts/src/core/Rollup.sol
@@ -41,6 +41,7 @@ import {
   Epoch,
   Timestamp,
   CommitteeAttestations,
+  EpochProofExtLib,
   RollupOperationsExtLib,
   ValidatorOperationsExtLib,
   EthValue,
@@ -300,7 +301,7 @@ contract Rollup is IStaking, IValidatorSelection, IRollup, RollupCore {
     ProposedHeader[] calldata _headers,
     bytes calldata _blobPublicInputs
   ) external view override(IRollup) returns (bytes32[] memory) {
-    return RollupOperationsExtLib.getEpochProofPublicInputs(_start, _end, _args, _headers, _blobPublicInputs);
+    return EpochProofExtLib.getEpochProofPublicInputs(_start, _end, _args, _headers, _blobPublicInputs);
   }
 
   /**
diff --git a/l1-contracts/src/core/RollupCore.sol b/l1-contracts/src/core/RollupCore.sol
index cc66c96895e2..ac0a89dfa0d5 100644
--- a/l1-contracts/src/core/RollupCore.sol
+++ b/l1-contracts/src/core/RollupCore.sol
@@ -18,6 +18,7 @@ import {IOutbox} from "@aztec/core/interfaces/messagebridge/IOutbox.sol";
 import {Constants} from "@aztec/core/libraries/ConstantsGen.sol";
 import {CommitteeAttestations} from "@aztec/core/libraries/rollup/AttestationLib.sol";
 import {Errors} from "@aztec/core/libraries/Errors.sol";
+import {EpochProofExtLib} from "@aztec/core/libraries/rollup/EpochProofExtLib.sol";
 import {RollupOperationsExtLib} from "@aztec/core/libraries/rollup/RollupOperationsExtLib.sol";
 import {ValidatorOperationsExtLib} from "@aztec/core/libraries/rollup/ValidatorOperationsExtLib.sol";
 import {SlasherDeploymentExtLib} from "@aztec/core/libraries/rollup/SlasherDeploymentExtLib.sol";
@@ -466,7 +467,7 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali
    * @param _args Contains the epoch range, public inputs, fees, attestations, and the ZK proof
    */
   function submitEpochRootProof(SubmitEpochRootProofArgs calldata _args) external override(IRollupCore) {
-    RollupOperationsExtLib.submitEpochRootProof(_args);
+    EpochProofExtLib.submitEpochRootProof(_args);
   }
 
   /**
diff --git a/l1-contracts/src/core/libraries/rollup/EpochProofExtLib.sol b/l1-contracts/src/core/libraries/rollup/EpochProofExtLib.sol
new file mode 100644
index 000000000000..a71251c19a7b
--- /dev/null
+++ b/l1-contracts/src/core/libraries/rollup/EpochProofExtLib.sol
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2024 Aztec Labs.
+pragma solidity >=0.8.27;
+
+import {SubmitEpochRootProofArgs, PublicInputArgs} from "@aztec/core/interfaces/IRollup.sol";
+import {ProposedHeader} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol";
+import {EpochProofLib} from "./EpochProofLib.sol";
+
+/**
+ * @title EpochProofExtLib - External Rollup Library (Epoch Proof Functions)
+ * @author Aztec Labs
+ * @notice External library containing epoch-proof functions for the Rollup contract to avoid exceeding max
+ * contract size.
+ *
+ * @dev This library serves as an external library for the Rollup contract, splitting off the epoch proof
+ *      submission and public-input computation from RollupOperationsExtLib, which the streaming inbox
+ *      validation pushed over the deployable size limit. The library contains external functions primarily
+ *      focused on:
+ *      - Epoch proof submission and verification
+ *      - Epoch proof public input computation
+ */
+library EpochProofExtLib {
+  function submitEpochRootProof(SubmitEpochRootProofArgs calldata _args) external {
+    EpochProofLib.submitEpochRootProof(_args);
+  }
+
+  function getEpochProofPublicInputs(
+    uint256 _start,
+    uint256 _end,
+    PublicInputArgs calldata _args,
+    ProposedHeader[] calldata _headers,
+    bytes calldata _blobPublicInputs
+  ) external view returns (bytes32[] memory) {
+    return EpochProofLib.getEpochProofPublicInputs(_start, _end, _args, _headers, _blobPublicInputs);
+  }
+}
diff --git a/l1-contracts/src/core/libraries/rollup/RollupOperationsExtLib.sol b/l1-contracts/src/core/libraries/rollup/RollupOperationsExtLib.sol
index 5d40cf46832b..8d3a5a5e93b2 100644
--- a/l1-contracts/src/core/libraries/rollup/RollupOperationsExtLib.sol
+++ b/l1-contracts/src/core/libraries/rollup/RollupOperationsExtLib.sol
@@ -4,12 +4,9 @@
 pragma solidity >=0.8.27;
 
 import {Errors} from "@aztec/core/libraries/Errors.sol";
-import {SubmitEpochRootProofArgs, PublicInputArgs} from "@aztec/core/interfaces/IRollup.sol";
 import {STFLib} from "@aztec/core/libraries/rollup/STFLib.sol";
 import {Timestamp, TimeLib, Slot, Epoch} from "@aztec/core/libraries/TimeLib.sol";
 import {BlobLib} from "@aztec-blob-lib/BlobLib.sol";
-import {EpochProofLib} from "./EpochProofLib.sol";
-import {ProposedHeader} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol";
 import {AttestationLib} from "@aztec/core/libraries/rollup/AttestationLib.sol";
 import {
   ProposeLib,
@@ -21,16 +18,16 @@ import {
 import {Signature} from "@aztec/shared/libraries/SignatureLib.sol";
 
 /**
- * @title RollupOperationsExtLib - External Rollup Library (Proposal and Proof Verification Functions)
+ * @title RollupOperationsExtLib - External Rollup Library (Proposal Functions)
  * @author Aztec Labs
  * @notice External library containing proposal-related functions for the Rollup contract to avoid exceeding max
  * contract size.
  *
  * @dev This library serves as an external library for the Rollup contract, splitting off proposal-related
- *      functionality to keep the main contract within the maximum contract size limit. The library contains
- *      external functions primarily focused on:
+ *      functionality to keep the main contract within the maximum contract size limit. Epoch-proof functions
+ *      live in EpochProofExtLib to keep this library itself deployable. The library contains external
+ *      functions primarily focused on:
  *      - Checkpoint proposal submission and validation
- *      - Epoch proof submission and verification
  *      - Blob validation and commitment management
  *      - Chain pruning operations
  */
@@ -39,10 +36,6 @@ library RollupOperationsExtLib {
   using TimeLib for Slot;
   using AttestationLib for CommitteeAttestations;
 
-  function submitEpochRootProof(SubmitEpochRootProofArgs calldata _args) external {
-    EpochProofLib.submitEpochRootProof(_args);
-  }
-
   function validateHeaderWithAttestations(
     ValidateHeaderArgs calldata _args,
     CommitteeAttestations calldata _attestations,
@@ -78,16 +71,6 @@ library RollupOperationsExtLib {
     STFLib.prune();
   }
 
-  function getEpochProofPublicInputs(
-    uint256 _start,
-    uint256 _end,
-    PublicInputArgs calldata _args,
-    ProposedHeader[] calldata _headers,
-    bytes calldata _blobPublicInputs
-  ) external view returns (bytes32[] memory) {
-    return EpochProofLib.getEpochProofPublicInputs(_start, _end, _args, _headers, _blobPublicInputs);
-  }
-
   function validateBlobs(bytes calldata _blobsInput, bool _checkBlob)
     external
     view

From 77780ecf35d104176b8d4275f147825b4e3179a8 Mon Sep 17 00:00:00 2001
From: Santiago Palladino <santiago@aztec-labs.com>
Date: Sun, 19 Jul 2026 17:49:53 -0300
Subject: [PATCH 22/22] test(fast-inbox): drop the legacy message-mismatch
 proposal test at the flip (A-1384)

The validator no longer fetches per-checkpoint messages to compare against the proposal; a wrong
message set now surfaces as a streaming bucket hash mismatch, covered by the proposal handler
streaming-check tests.
---
 yarn-project/validator-client/src/validator.test.ts | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/yarn-project/validator-client/src/validator.test.ts b/yarn-project/validator-client/src/validator.test.ts
index 6adca5bd39c0..cbec821c8b2f 100644
--- a/yarn-project/validator-client/src/validator.test.ts
+++ b/yarn-project/validator-client/src/validator.test.ts
@@ -1455,13 +1455,6 @@ describe('ValidatorClient', () => {
       expect(isValid).toBe(false);
     });
 
-    it('should return false if messages do not match', async () => {
-      l1ToL2MessageSource.getL1ToL2Messages.mockResolvedValue([Fr.random()]);
-
-      const isValid = await validatorClient.validateBlockProposal(proposal, sender);
-      expect(isValid).toBe(false);
-    });
-
     describe('non-first block in checkpoint validation', () => {
       // When indexWithinCheckpoint > 0, global variables must match parent block (except blockNumber).
       // The inHash validation is implicitly handled: all blocks in a checkpoint share the same