chore(fast-inbox): remove world-state padding remnants and node simulator message fetch (A-1388)

Drops the no-op first-in-checkpoint padding alias and its stale docs in world-state,
and removes the obsolete non-first-block-empty-bundle transitional test. The node
public-calls simulator no longer fetches next-checkpoint messages via the removed
per-checkpoint API and drops its now-unused l1ToL2MessageSource dependency, simulating
against the fork's current tree (streaming Inbox consumes per block). Rewrites the
THREAT_MODEL inHash/consume passages to the consensus rolling-hash / bucket model.

Author: spalladino

yarn-project/THREAT_MODEL.md

@@ -203,8 +203,9 @@ L1 does **not** verify committee attestations at propose time (gas optimization)
   invalid attestations is rejected without touching potentially malformed blob data
   ([validation.ts](archiver/src/modules/validation.ts)).
 - **C2 — Sync never bricks.** The archiver skips invalid checkpoints, advances its syncpoint past them, and keeps
-  processing. The `inHash` check cannot be weaponized: L1 enforces `header.inHash == inbox.consume(...)` at propose
-  time, so a local mismatch indicates a node bug, not attacker-controlled input (`ProposeLib`).
+  processing. The consensus rolling-hash check cannot be weaponized: L1 enforces at propose time that the checkpoint
+  header's `inboxRollingHash` matches the rolling hash of the Inbox bucket the checkpoint consumes through, so a local
+  mismatch indicates a node bug, not attacker-controlled input (`ProposeLib`).
 - **C3 — Bad-attestation checkpoints are removable and unprovable.** Anyone can call `invalidateBadAttestation` /
   `invalidateInsufficientAttestations` to purge them (no rebate; expected callers: next proposer, then committee, then
   any validator, with timed fallbacks in the sequencer). They cannot enter the proven chain: `submitEpochRootProof`
@@ -236,8 +237,8 @@ L1 does **not** verify committee attestations at propose time (gas optimization)
 
 - **S1 — Sync everything provable.** Nodes must be able to sync from L1 any checkpoint that provers can prove, even if
   local validator policy would have refused to attest to it. Validator-side caps (`VALIDATOR_MAX_*`) apply only to p2p
-  proposal validation; the archiver's L1 path enforces only attestation validity, `inHash` consistency, and structural
-  blob decoding. Rationale: escape-hatch and malicious-quorum checkpoints bypass validator policy but can still reach
+  proposal validation; the archiver's L1 path enforces only attestation validity, consensus rolling-hash consistency,
+  and structural blob decoding. Rationale: escape-hatch and malicious-quorum checkpoints bypass validator policy but can still reach
   the proven chain, and a node that refuses to sync them forks itself off.
 - **S2 — L1 reorg resilience.** Message and checkpoint sync detect L1 reorgs (rolling hashes, archive root comparison),
   unwind to the common ancestor, and re-fetch — including the subtle case of checkpoints added *behind* the syncpoint.

yarn-project/aztec-node/src/aztec-node/node_public_calls_simulator.test.ts

@@ -1,4 +1,3 @@
-import { L1ToL2MessagesNotReadyError } from '@aztec/archiver';
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { type FeeHeader, RollupContract } from '@aztec/ethereum/contracts';
 import {
@@ -26,10 +25,9 @@ import type { ProposedCheckpointData } from '@aztec/stdlib/checkpoint';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { mockTx } from '@aztec/stdlib/testing';
-import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import {
   BlockHeader,
   type CheckpointGlobalVariables,
@@ -50,7 +48,6 @@ const ROLLUP_ADDRESS = EthAddress.random();
 describe('NodePublicCallsSimulator', () => {
   let blockSource: MockProxy<L2BlockSource>;
   let worldStateSynchronizer: MockProxy<WorldStateSynchronizer>;
-  let l1ToL2MessageSource: MockProxy<L1ToL2MessageSource>;
   let contractDataSource: MockProxy<ContractDataSource>;
   let globalVariableBuilder: MockProxy<GlobalVariableBuilder>;
   let rollupContract: MockProxy<RollupContract>;
@@ -127,7 +124,6 @@ describe('NodePublicCallsSimulator', () => {
 
     blockSource = mock<L2BlockSource>();
     worldStateSynchronizer = mock<WorldStateSynchronizer>();
-    l1ToL2MessageSource = mock<L1ToL2MessageSource>();
     contractDataSource = mock<ContractDataSource>();
     globalVariableBuilder = mock<GlobalVariableBuilder>();
     rollupContract = mock<RollupContract>();
@@ -140,7 +136,6 @@ describe('NodePublicCallsSimulator', () => {
     (merkleTreeFork as unknown as { [Symbol.asyncDispose]: () => Promise<void> })[Symbol.asyncDispose] = () =>
       Promise.resolve();
     worldStateSynchronizer.fork.mockResolvedValue(merkleTreeFork);
-    l1ToL2MessageSource.getL1ToL2Messages.mockResolvedValue([]);
     blockSource.getPendingChainValidationStatus.mockResolvedValue({ valid: true });
     blockSource.getProposedCheckpointData.mockResolvedValue(undefined);
 
@@ -168,7 +163,6 @@ describe('NodePublicCallsSimulator', () => {
     simulator = new NodePublicCallsSimulator({
       blockSource,
       worldStateSynchronizer,
-      l1ToL2MessageSource,
       contractDataSource,
       globalVariableBuilder,
       rollupContract,
@@ -232,7 +226,6 @@ describe('NodePublicCallsSimulator', () => {
 
       await simulator.simulate(tx);
 
-      expect(l1ToL2MessageSource.getL1ToL2Messages).not.toHaveBeenCalled();
       expect(merkleTreeFork.appendLeaves).not.toHaveBeenCalled();
     });
 
@@ -245,8 +238,7 @@ describe('NodePublicCallsSimulator', () => {
 
       await expect(simulator.simulate(tx)).rejects.toThrow();
 
-      // Must not treat the next block as opening a new checkpoint and re-insert the ongoing checkpoint's messages.
-      expect(l1ToL2MessageSource.getL1ToL2Messages).not.toHaveBeenCalled();
+      // Must not treat the next block as opening a new checkpoint.
       expect(merkleTreeFork.appendLeaves).not.toHaveBeenCalled();
       expect(globalVariableBuilder.buildCheckpointGlobalVariables).not.toHaveBeenCalled();
     });
@@ -281,35 +273,17 @@ describe('NodePublicCallsSimulator', () => {
       expect(plan?.chainTipsOverride).toEqual({ pending: CheckpointNumber(1), proven: CheckpointNumber(1) });
     });
 
-    it('inserts L1-to-L2 messages for the next checkpoint', async () => {
+    it('does not insert L1-to-L2 messages when opening a new checkpoint', async () => {
       const tx = await lowGasTx();
-      const messages = [Fr.fromString('0x1234'), Fr.fromString('0x5678')];
       blockSource.getL2Tips.mockResolvedValue(setupBoundary());
       blockSource.getBlockData.mockImplementation((query: BlockQuery) =>
         Promise.resolve('number' in query ? makeBlockData(query.number, SlotNumber(5)) : undefined),
       );
       mockNextL1Slot(SlotNumber(20));
-      l1ToL2MessageSource.getL1ToL2Messages.mockResolvedValue(messages);
-
-      await simulator.simulate(tx);
-
-      // targetCheckpoint = proposedCheckpoint.number + 1
-      expect(l1ToL2MessageSource.getL1ToL2Messages).toHaveBeenCalledWith(CheckpointNumber(2));
-      const [treeId, appended] = merkleTreeFork.appendLeaves.mock.calls[0];
-      expect(treeId).toEqual(MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
-      expect(appended.slice(0, 2)).toEqual(messages);
-    });
-
-    it('tolerates L1ToL2MessagesNotReadyError and simulates without messages', async () => {
-      const tx = await lowGasTx();
-      blockSource.getL2Tips.mockResolvedValue(setupBoundary());
-      blockSource.getBlockData.mockImplementation((query: BlockQuery) =>
-        Promise.resolve('number' in query ? makeBlockData(query.number, SlotNumber(5)) : undefined),
-      );
-      mockNextL1Slot(SlotNumber(20));
-      l1ToL2MessageSource.getL1ToL2Messages.mockRejectedValue(new L1ToL2MessagesNotReadyError(CheckpointNumber(2), 0n));
 
       await expect(simulator.simulate(tx)).resolves.toBeDefined();
+
+      // Streaming Inbox: the next checkpoint's messages are consumed per block, so none are appended here.
       expect(merkleTreeFork.appendLeaves).not.toHaveBeenCalled();
     });
 
@@ -408,7 +382,6 @@ describe('NodePublicCallsSimulator', () => {
       new NodePublicCallsSimulator({
         blockSource,
         worldStateSynchronizer,
-        l1ToL2MessageSource,
         contractDataSource,
         globalVariableBuilder,
         epochCache,

yarn-project/aztec-node/src/aztec-node/node_public_calls_simulator.ts

@@ -1,4 +1,3 @@
-import { L1ToL2MessagesNotReadyError } from '@aztec/archiver';
 import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import {
@@ -8,20 +7,17 @@ import {
 } from '@aztec/ethereum/contracts';
 import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { BadRequestError } from '@aztec/foundation/json-rpc';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
-import { isErrorClass } from '@aztec/foundation/types';
 import { type AvmSimulator, PublicContractsDB, PublicProcessorFactory } from '@aztec/simulator/server';
 import { CollectionLimitsConfig, PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2BlockSource, L2Tips } from '@aztec/stdlib/block';
 import { type ProposedCheckpointData, buildCheckpointSimulationOverridesPlan } from '@aztec/stdlib/checkpoint';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { type L1ToL2MessageSource, appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
 import type { CoordinationSignatureContext } from '@aztec/stdlib/p2p';
 import {
   type GlobalVariableBuilder,
@@ -46,7 +42,6 @@ export interface NodePublicCallsSimulatorConfig {
 export interface NodePublicCallsSimulatorDeps {
   blockSource: L2BlockSource;
   worldStateSynchronizer: WorldStateSynchronizer;
-  l1ToL2MessageSource: L1ToL2MessageSource;
   contractDataSource: ContractDataSource;
   globalVariableBuilder: GlobalVariableBuilder;
   /**
@@ -87,7 +82,6 @@ export interface NodePublicCallsSimulatorDeps {
 export class NodePublicCallsSimulator {
   private readonly blockSource: L2BlockSource;
   private readonly worldStateSynchronizer: WorldStateSynchronizer;
-  private readonly l1ToL2MessageSource: L1ToL2MessageSource;
   private readonly contractDataSource: ContractDataSource;
   private readonly globalVariableBuilder: GlobalVariableBuilder;
   private readonly rollupContract: RollupContract | undefined;
@@ -101,7 +95,6 @@ export class NodePublicCallsSimulator {
   constructor(deps: NodePublicCallsSimulatorDeps) {
     this.blockSource = deps.blockSource;
     this.worldStateSynchronizer = deps.worldStateSynchronizer;
-    this.l1ToL2MessageSource = deps.l1ToL2MessageSource;
     this.contractDataSource = deps.contractDataSource;
     this.globalVariableBuilder = deps.globalVariableBuilder;
     this.rollupContract = deps.rollupContract;
@@ -157,9 +150,7 @@ export class NodePublicCallsSimulator {
     // the proposed-checkpoint terminating block; it opens a new checkpoint when they coincide.
     const atCheckpointBoundary = proposedCheckpointLastBlock === l2Tips.proposed.number;
 
-    // `targetCheckpoint` is the checkpoint whose L1-to-L2 messages must be inserted into the fork
-    // before simulation. Only set when opening a new checkpoint, where the next block is its first block.
-    const { globalVariables: newGlobalVariables, targetCheckpoint } = atCheckpointBoundary
+    const { globalVariables: newGlobalVariables } = atCheckpointBoundary
       ? await this.buildGlobalVariablesForNewCheckpoint(l2Tips, proposedCheckpointData, blockNumber)
       : { globalVariables: await this.copyGlobalVariablesFromLatestProposedBlock(latestBlockNumber, blockNumber) };
 
@@ -184,19 +175,12 @@ export class NodePublicCallsSimulator {
     // Ensure world-state has caught up with the latest block we loaded from the archiver
     await this.worldStateSynchronizer.syncImmediate(latestBlockNumber);
 
-    const nextCheckpointMessages = await this.getNextCheckpointMessages(targetCheckpoint);
-
-    // Request a new fork of the world state at the latest block number, and apply any overrides and next checkpoint messages to it before simulation
+    // Request a new fork of the world state at the latest block number, and apply any overrides to it before
+    // simulation. The next checkpoint's L1-to-L2 messages are not inserted here: under the streaming Inbox
+    // (AZIP-22 Fast Inbox) a checkpoint's messages are consumed per block, so the simulation runs against the
+    // fork's current tree without predicting the next block's message bundle.
     await using merkleTreeFork = await this.worldStateSynchronizer.fork(latestBlockNumber);
 
-    if (nextCheckpointMessages !== undefined) {
-      this.log.debug(
-        `Appending ${nextCheckpointMessages.length} L1-to-L2 messages to the world state tree for the next checkpoint`,
-        { checkpointNumber: targetCheckpoint },
-      );
-      await appendL1ToL2MessagesToTree(merkleTreeFork, nextCheckpointMessages);
-    }
-
     await applyPublicDataOverrides(merkleTreeFork, overrides?.publicStorage);
 
     const config = PublicSimulatorConfig.from({
@@ -235,37 +219,6 @@ export class NodePublicCallsSimulator {
     );
   }
 
-  /**
-   * Fetches the next checkpoint's L1-to-L2 messages to insert into the fork before simulation. Only set
-   * when opening a new checkpoint; when continuing an in-progress checkpoint the ongoing checkpoint's
-   * messages were already applied when its first block synced, so inserting here would double-count them
-   * — which is why a missing header for the latest proposed block throws rather than falling through to
-   * this path. A not-ready or failed fetch degrades to simulating without the messages rather than
-   * failing the request.
-   */
-  private async getNextCheckpointMessages(targetCheckpoint: CheckpointNumber | undefined): Promise<Fr[] | undefined> {
-    if (targetCheckpoint === undefined) {
-      return undefined;
-    }
-    try {
-      return await this.l1ToL2MessageSource.getL1ToL2Messages(targetCheckpoint);
-    } catch (err) {
-      if (isErrorClass(err, L1ToL2MessagesNotReadyError)) {
-        this.log.warn(
-          `L1-to-L2 messages for checkpoint ${targetCheckpoint} are not ready yet (simulating without them)`,
-          { checkpointNumber: targetCheckpoint },
-        );
-      } else {
-        this.log.error(
-          `Failed to get L1-to-L2 messages for checkpoint ${targetCheckpoint} (simulating without them)`,
-          err,
-          { checkpointNumber: targetCheckpoint },
-        );
-      }
-      return undefined;
-    }
-  }
-
   /**
    * Continues an in-progress checkpoint: the next block extends the checkpoint the latest proposed
    * block belongs to. Every block in a checkpoint shares the same `CheckpointGlobalVariables`, so the
@@ -298,19 +251,14 @@ export class NodePublicCallsSimulator {
    * sequencer applies so the simulated mana min fee matches what the sequencer will write into the
    * block header. Coinbase and fee recipient stay zero (we cannot know the future proposer's payout
    * addresses), unlike continuing an in-progress checkpoint which inherits the real ones from the
-   * proposed header. Returns the target checkpoint so the caller inserts that checkpoint's L1-to-L2
-   * messages into the fork.
+   * proposed header.
    */
   private async buildGlobalVariablesForNewCheckpoint(
     l2Tips: L2Tips,
     proposedCheckpointData: ProposedCheckpointData | undefined,
     blockNumber: BlockNumber,
-  ): Promise<{ globalVariables: GlobalVariables; targetCheckpoint: CheckpointNumber }> {
+  ): Promise<{ globalVariables: GlobalVariables }> {
     const checkpointedCheckpointNumber = l2Tips.checkpointed.checkpoint.number;
-    // The new checkpoint sits on top of the proposed one when pipelining, otherwise on the
-    // checkpointed tip. The target slot and the overrides plan both derive from the single
-    // `proposedCheckpointData` read, so they cannot disagree about the proposed parent.
-    const proposedCheckpointNumber = proposedCheckpointData?.checkpointNumber ?? checkpointedCheckpointNumber;
 
     const targetSlot = this.computeTargetSlot(proposedCheckpointData);
     const plan = await this.buildSimulationOverridesPlan(proposedCheckpointData, checkpointedCheckpointNumber);
@@ -324,7 +272,6 @@ export class NodePublicCallsSimulator {
 
     return {
       globalVariables: GlobalVariables.from({ blockNumber, ...checkpointGlobalVariables }),
-      targetCheckpoint: CheckpointNumber(proposedCheckpointNumber + 1),
     };
   }
 

yarn-project/aztec-node/src/aztec-node/server.ts

@@ -241,7 +241,6 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, AztecNodeDeb
     this.nodePublicCallsSimulator = new NodePublicCallsSimulator({
       blockSource: this.blockSource,
       worldStateSynchronizer: this.worldStateSynchronizer,
-      l1ToL2MessageSource: this.l1ToL2MessageSource,
       contractDataSource: this.contractDataSource,
       globalVariableBuilder: this.globalVariableBuilder,
       rollupContract: this.rollupContract,

yarn-project/prover-node/src/prover-node.test.ts

@@ -653,7 +653,6 @@ describe('ProverNode', () => {
    */
   function setupRegistrationSuccess() {
     worldState.syncImmediate.mockResolvedValue(undefined as any);
-    l1ToL2MessageSource.getL1ToL2Messages.mockResolvedValue([]);
     l2BlockSource.getBlockData.mockResolvedValue({
       header: { lastArchive: { root: Fr.ZERO }, state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 0 } } },
     } as any);

yarn-project/world-state/src/native/native_world_state.ts

@@ -266,7 +266,6 @@ 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 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.
@@ -294,7 +293,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
         // Forwarded so the native sync verifies the archive root against canonical and rejects a divergent tree.
         expectedArchiveRoot: l2Block.archive.root.toBuffer(),
         expectedPreviousArchiveRoot: l2Block.header.lastArchive.root.toBuffer(),
-        paddedL1ToL2Messages: paddedL1ToL2Messages.map(serializeLeaf),
+        paddedL1ToL2Messages: l1ToL2Messages.map(serializeLeaf),
         paddedNoteHashes: paddedNoteHashes.map(serializeLeaf),
         paddedNullifiers: paddedNullifiers.map(serializeLeaf),
         publicDataWrites: publicDataWrites.map(serializeLeaf),

yarn-project/world-state/src/world-state-db/merkle_tree_db.ts

@@ -33,9 +33,8 @@ export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations, Reado
   /**
    * Handles a single L2 block: inserts its note hashes, nullifiers, public data writes, and the block's L1-to-L2
    * message bundle into the merkle trees. Any block may carry a message bundle and transition the L1-to-L2 message
-   * tree, not just the first block of a checkpoint. A first-in-checkpoint bundle is padded to
-   * MAX_L1_TO_L2_MSGS_PER_CHECKPOINT to match how the circuits build the tree; a non-first bundle is appended
-   * exactly as given. Padding is a transitional concern of this method that moves entirely to the caller at the flip.
+   * tree, not just the first block of a checkpoint. The bundle's real (unpadded, compact) leaves are appended as
+   * given, matching how the circuits build the tree (AZIP-22 Fast Inbox).
    * @param block - The L2 block to handle.
    * @param l1ToL2Messages - The L1 to L2 messages for the block.
    */