@aztec/archiver 0.0.1-commit.d431d1c → 0.0.1-commit.dbf9cec

package/src/archiver.ts

@@ -1,5 +1,4 @@
 import type { BlobClientInterface } from '@aztec/blob-client/client';
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { EpochCache } from '@aztec/epoch-cache';
 import { BlockTagTooOldError, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
@@ -15,9 +14,7 @@ import { RunningPromise, makeLoggingErrorHandler } from '@aztec/foundation/runni
 import { DateProvider } from '@aztec/foundation/timer';
 import {
   type ArchiverEmitter,
-  type CheckpointId,
-  GENESIS_CHECKPOINT_HEADER_HASH,
-  L2BlockNew,
+  L2Block,
   type L2BlockSink,
   type L2Tips,
   type ValidateCheckpointResult,
@@ -26,6 +23,7 @@ import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import {
   type L1RollupConstants,
   getEpochNumberAtTimestamp,
+  getSlotAtNextL1Block,
   getSlotAtTimestamp,
   getSlotRangeForEpoch,
   getTimestampRangeForEpoch,
@@ -40,13 +38,14 @@ import { ArchiverDataStoreUpdater } from './modules/data_store_updater.js';
 import type { ArchiverInstrumentation } from './modules/instrumentation.js';
 import type { ArchiverL1Synchronizer } from './modules/l1_synchronizer.js';
 import type { KVArchiverDataStore } from './store/kv_archiver_store.js';
+import { L2TipsCache } from './store/l2_tips_cache.js';
 
 /** Export ArchiverEmitter for use in factory and tests. */
 export type { ArchiverEmitter };
 
 /** Request to add a block to the archiver, queued for processing by the sync loop. */
 type AddBlockRequest = {
-  block: L2BlockNew;
+  block: L2Block;
   resolve: () => void;
   reject: (err: Error) => void;
 };
@@ -68,7 +67,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   public readonly events: ArchiverEmitter;
 
   /** A loop in which we will be continually fetching new checkpoints. */
-  private runningPromise: RunningPromise;
+  protected runningPromise: RunningPromise;
 
   /** L1 synchronizer that handles fetching checkpoints and messages from L1. */
   private readonly synchronizer: ArchiverL1Synchronizer;
@@ -82,6 +81,9 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   /** Helper to handle updates to the store */
   private readonly updater: ArchiverDataStoreUpdater;
 
+  /** In-memory cache for L2 chain tips. */
+  private readonly l2TipsCache: L2TipsCache;
+
   public readonly tracer: Tracer;
 
   /**
@@ -121,6 +123,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     protected override readonly l1Constants: L1RollupConstants & { l1StartBlockHash: Buffer32; genesisArchiveRoot: Fr },
     synchronizer: ArchiverL1Synchronizer,
     events: ArchiverEmitter,
+    l2TipsCache?: L2TipsCache,
     private readonly log: Logger = createLogger('archiver'),
   ) {
     super(dataStore, l1Constants);
@@ -129,7 +132,8 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     this.initialSyncPromise = promiseWithResolvers();
     this.synchronizer = synchronizer;
     this.events = events;
-    this.updater = new ArchiverDataStoreUpdater(this.dataStore);
+    this.l2TipsCache = l2TipsCache ?? new L2TipsCache(this.dataStore.blockStore);
+    this.updater = new ArchiverDataStoreUpdater(this.dataStore, this.l2TipsCache);
 
     // Running promise starts with a small interval inbetween runs, so all iterations needed for the initial sync
     // are done as fast as possible. This then gets updated once the initial sync completes.
@@ -158,7 +162,11 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
 
     await this.blobClient.testSources();
     await this.synchronizer.testEthereumNodeSynced();
-    await validateAndLogTraceAvailability(this.debugClient, this.config.ethereumAllowNoDebugHosts ?? false);
+    await validateAndLogTraceAvailability(
+      this.debugClient,
+      this.config.ethereumAllowNoDebugHosts ?? false,
+      this.log.getBindings(),
+    );
 
     // Log initial state for the archiver
     const { l1StartBlock } = this.l1Constants;
@@ -187,7 +195,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
    * @param block - The L2 block to add.
    * @returns A promise that resolves when the block has been added to the store, or rejects on error.
    */
-  public addBlock(block: L2BlockNew): Promise<void> {
+  public addBlock(block: L2Block): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       this.blockQueue.push({ block, resolve, reject });
       this.log.debug(`Queued block ${block.number} for processing`);
@@ -212,10 +220,25 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     const queuedItems = this.blockQueue.splice(0, this.blockQueue.length);
     this.log.debug(`Processing ${queuedItems.length} queued block(s)`);
 
+    // Calculate slot threshold for validation
+    const l1Timestamp = this.synchronizer.getL1Timestamp();
+    const slotAtNextL1Block =
+      l1Timestamp === undefined ? undefined : getSlotAtNextL1Block(l1Timestamp, this.l1Constants);
+
     // Process each block individually to properly resolve/reject each promise
     for (const { block, resolve, reject } of queuedItems) {
+      const blockSlot = block.header.globalVariables.slotNumber;
+      if (slotAtNextL1Block !== undefined && blockSlot < slotAtNextL1Block) {
+        this.log.warn(
+          `Rejecting proposed block ${block.number} for past slot ${blockSlot} (current is ${slotAtNextL1Block})`,
+          { block: block.toBlockInfo(), l1Timestamp, slotAtNextL1Block },
+        );
+        reject(new Error(`Block ${block.number} is for past slot ${blockSlot} (current is ${slotAtNextL1Block})`));
+        continue;
+      }
+
       try {
-        await this.updater.addBlocks([block]);
+        await this.updater.addProposedBlocks([block]);
         this.log.debug(`Added block ${block.number} to store`);
         resolve();
       } catch (err: any) {
@@ -323,8 +346,11 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   }
 
   public async isEpochComplete(epochNumber: EpochNumber): Promise<boolean> {
-    // The epoch is complete if the current L2 block is the last one in the epoch (or later)
-    const header = await this.getBlockHeader('latest');
+    // The epoch is complete if the current checkpointed L2 block is the last one in the epoch (or later).
+    // We use the checkpointed block number (synced from L1) instead of 'latest' to avoid returning true
+    // prematurely when proposed blocks have been pushed to the archiver but not yet checkpointed on L1.
+    const checkpointedBlockNumber = await this.getCheckpointedL2BlockNumber();
+    const header = checkpointedBlockNumber > 0 ? await this.getBlockHeader(checkpointedBlockNumber) : undefined;
     const slot = header ? header.globalVariables.slotNumber : undefined;
     const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
     if (slot && slot >= endSlot) {
@@ -355,8 +381,8 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     return this.initialSyncComplete;
   }
 
-  public unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
-    return this.updater.unwindCheckpoints(from, checkpointsToUnwind);
+  public removeCheckpointsAfter(checkpointNumber: CheckpointNumber): Promise<boolean> {
+    return this.updater.removeCheckpointsAfter(checkpointNumber);
   }
 
   /** Used by TXE to add checkpoints directly without syncing from L1. */
@@ -364,121 +390,12 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     checkpoints: PublishedCheckpoint[],
     pendingChainValidationStatus?: ValidateCheckpointResult,
   ): Promise<boolean> {
-    await this.updater.setNewCheckpointData(checkpoints, pendingChainValidationStatus);
+    await this.updater.addCheckpoints(checkpoints, pendingChainValidationStatus);
     return true;
   }
 
-  public async getL2Tips(): Promise<L2Tips> {
-    const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber] = await Promise.all([
-      this.getBlockNumber(),
-      this.getProvenBlockNumber(),
-      this.getCheckpointedBlockNumber(),
-    ] as const);
-
-    // TODO(#13569): Compute proper finalized block number based on L1 finalized block.
-    // We just force it 2 epochs worth of proven data for now.
-    // NOTE: update end-to-end/src/e2e_epochs/epochs_empty_blocks.test.ts as that uses finalized blocks in computations
-    const finalizedBlockNumber = BlockNumber(Math.max(provenBlockNumber - this.l1Constants.epochDuration * 2, 0));
-
-    const beforeInitialblockNumber = BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
-
-    // Get the latest block header and checkpointed blocks for proven, finalised and checkpointed blocks
-    const [latestBlockHeader, provenCheckpointedBlock, finalizedCheckpointedBlock, checkpointedBlock] =
-      await Promise.all([
-        latestBlockNumber > beforeInitialblockNumber ? this.getBlockHeader(latestBlockNumber) : undefined,
-        provenBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(provenBlockNumber) : undefined,
-        finalizedBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(finalizedBlockNumber) : undefined,
-        checkpointedBlockNumber > beforeInitialblockNumber
-          ? this.getCheckpointedBlock(checkpointedBlockNumber)
-          : undefined,
-      ] as const);
-
-    if (latestBlockNumber > beforeInitialblockNumber && !latestBlockHeader) {
-      throw new Error(`Failed to retrieve latest block header for block ${latestBlockNumber}`);
-    }
-
-    // Checkpointed blocks must exist for proven, finalized and checkpointed tips if they are beyond the initial block number.
-    if (checkpointedBlockNumber > beforeInitialblockNumber && !checkpointedBlock?.block.header) {
-      throw new Error(
-        `Failed to retrieve checkpointed block header for block ${checkpointedBlockNumber} (latest block is ${latestBlockNumber})`,
-      );
-    }
-
-    if (provenBlockNumber > beforeInitialblockNumber && !provenCheckpointedBlock?.block.header) {
-      throw new Error(
-        `Failed to retrieve proven checkpointed for block ${provenBlockNumber} (latest block is ${latestBlockNumber})`,
-      );
-    }
-
-    if (finalizedBlockNumber > beforeInitialblockNumber && !finalizedCheckpointedBlock?.block.header) {
-      throw new Error(
-        `Failed to retrieve finalized block header for block ${finalizedBlockNumber} (latest block is ${latestBlockNumber})`,
-      );
-    }
-
-    const latestBlockHeaderHash = (await latestBlockHeader?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
-    const provenBlockHeaderHash = (await provenCheckpointedBlock?.block.header?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
-    const finalizedBlockHeaderHash =
-      (await finalizedCheckpointedBlock?.block.header?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
-    const checkpointedBlockHeaderHash = (await checkpointedBlock?.block.header?.hash()) ?? GENESIS_BLOCK_HEADER_HASH;
-
-    // Now attempt to retrieve checkpoints for proven, finalised and checkpointed blocks
-    const [[provenBlockCheckpoint], [finalizedBlockCheckpoint], [checkpointedBlockCheckpoint]] = await Promise.all([
-      provenCheckpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1)
-        : [undefined],
-      finalizedCheckpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1)
-        : [undefined],
-      checkpointedBlock !== undefined
-        ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1)
-        : [undefined],
-    ]);
-
-    const initialcheckpointId: CheckpointId = {
-      number: CheckpointNumber.ZERO,
-      hash: GENESIS_CHECKPOINT_HEADER_HASH.toString(),
-    };
-
-    const makeCheckpointId = (checkpoint: PublishedCheckpoint | undefined) => {
-      if (checkpoint === undefined) {
-        return initialcheckpointId;
-      }
-      return {
-        number: checkpoint.checkpoint.number,
-        hash: checkpoint.checkpoint.hash().toString(),
-      };
-    };
-
-    const l2Tips: L2Tips = {
-      proposed: {
-        number: latestBlockNumber,
-        hash: latestBlockHeaderHash.toString(),
-      },
-      proven: {
-        block: {
-          number: provenBlockNumber,
-          hash: provenBlockHeaderHash.toString(),
-        },
-        checkpoint: makeCheckpointId(provenBlockCheckpoint),
-      },
-      finalized: {
-        block: {
-          number: finalizedBlockNumber,
-          hash: finalizedBlockHeaderHash.toString(),
-        },
-        checkpoint: makeCheckpointId(finalizedBlockCheckpoint),
-      },
-      checkpointed: {
-        block: {
-          number: checkpointedBlockNumber,
-          hash: checkpointedBlockHeaderHash.toString(),
-        },
-        checkpoint: makeCheckpointId(checkpointedBlockCheckpoint),
-      },
-    };
-
-    return l2Tips;
+  public getL2Tips(): Promise<L2Tips> {
+    return this.l2TipsCache.getL2Tips();
   }
 
   public async rollbackTo(targetL2BlockNumber: BlockNumber): Promise<void> {
@@ -490,13 +407,12 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     if (targetL2BlockNumber >= currentL2Block) {
       throw new Error(`Target L2 block ${targetL2BlockNumber} must be less than current L2 block ${currentL2Block}`);
     }
-    const blocksToUnwind = currentL2Block - targetL2BlockNumber;
     const targetL2Block = await this.store.getCheckpointedBlock(targetL2BlockNumber);
     if (!targetL2Block) {
       throw new Error(`Target L2 block ${targetL2BlockNumber} not found`);
     }
     const targetL1BlockNumber = targetL2Block.l1.blockNumber;
-    const targetCheckpointNumber = CheckpointNumber.fromBlockNumber(targetL2BlockNumber);
+    const targetCheckpointNumber = targetL2Block.checkpointNumber;
     const targetL1Block = await this.publicClient.getBlock({
       blockNumber: targetL1BlockNumber,
       includeTransactions: false,
@@ -505,16 +421,18 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       throw new Error(`Missing L1 block ${targetL1BlockNumber}`);
     }
     const targetL1BlockHash = Buffer32.fromString(targetL1Block.hash);
-    this.log.info(`Unwinding ${blocksToUnwind} checkpoints from L2 block ${currentL2Block}`);
-    await this.updater.unwindCheckpoints(CheckpointNumber(currentL2Block), blocksToUnwind);
-    this.log.info(`Unwinding L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
+    this.log.info(
+      `Removing checkpoints after checkpoint ${targetCheckpointNumber} (target block ${targetL2BlockNumber})`,
+    );
+    await this.updater.removeCheckpointsAfter(targetCheckpointNumber);
+    this.log.info(`Rolling back L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
     await this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
     this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
     await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);
     await this.store.setMessageSynchedL1Block({ l1BlockNumber: targetL1BlockNumber, l1BlockHash: targetL1BlockHash });
     if (targetL2BlockNumber < currentProvenBlock) {
       this.log.info(`Clearing proven L2 block number`);
-      await this.store.setProvenCheckpointNumber(CheckpointNumber.ZERO);
+      await this.updater.setProvenCheckpointNumber(CheckpointNumber.ZERO);
     }
     // TODO(palla/reorg): Set the finalized block when we add support for it.
     // if (targetL2BlockNumber < currentFinalizedBlock) {

package/src/errors.ts

@@ -88,3 +88,15 @@ export class BlockNotFoundError extends Error {
     super(`Failed to find expected block number ${blockNumber}`);
   }
 }
+
+export class CannotOverwriteCheckpointedBlockError extends Error {
+  constructor(
+    public readonly blockNumber: number,
+    public readonly lastCheckpointedBlock: number,
+  ) {
+    super(
+      `Cannot add block ${blockNumber}: would overwrite checkpointed data (checkpointed up to block ${lastCheckpointedBlock})`,
+    );
+    this.name = 'CannotOverwriteCheckpointedBlockError';
+  }
+}

package/src/factory.ts

@@ -6,7 +6,6 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { merge } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
@@ -15,6 +14,7 @@ import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/prov
 import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
 import type { ArchiverEmitter } from '@aztec/stdlib/block';
 import { type ContractClassPublic, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { EventEmitter } from 'events';
@@ -25,19 +25,21 @@ import { type ArchiverConfig, mapArchiverConfig } from './config.js';
 import { ArchiverInstrumentation } from './modules/instrumentation.js';
 import { ArchiverL1Synchronizer } from './modules/l1_synchronizer.js';
 import { ARCHIVER_DB_VERSION, KVArchiverDataStore } from './store/kv_archiver_store.js';
+import { L2TipsCache } from './store/l2_tips_cache.js';
 
 export const ARCHIVER_STORE_NAME = 'archiver';
 
 /** Creates an archiver store. */
 export async function createArchiverStore(
   userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> & DataStoreConfig,
+  l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
 ) {
   const config = {
     ...userConfig,
     dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
   };
-  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config, createLogger('archiver:lmdb'));
-  return new KVArchiverDataStore(store, config.maxLogs);
+  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config);
+  return new KVArchiverDataStore(store, config.maxLogs, l1Constants);
 }
 
 /**
@@ -52,7 +54,7 @@ export async function createArchiver(
   deps: ArchiverDeps,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
 ): Promise<Archiver> {
-  const archiverStore = await createArchiverStore(config);
+  const archiverStore = await createArchiverStore(config, { epochDuration: config.aztecEpochDuration });
   await registerProtocolContracts(archiverStore);
 
   // Create Ethereum clients
@@ -76,14 +78,21 @@ export async function createArchiver(
   const inbox = new InboxContract(publicClient, config.l1Contracts.inboxAddress);
 
   // Fetch L1 constants from rollup contract
-  const [l1StartBlock, l1GenesisTime, proofSubmissionEpochs, genesisArchiveRoot, slashingProposerAddress] =
-    await Promise.all([
-      rollup.getL1StartBlock(),
-      rollup.getL1GenesisTime(),
-      rollup.getProofSubmissionEpochs(),
-      rollup.getGenesisArchiveTreeRoot(),
-      rollup.getSlashingProposerAddress(),
-    ] as const);
+  const [
+    l1StartBlock,
+    l1GenesisTime,
+    proofSubmissionEpochs,
+    genesisArchiveRoot,
+    slashingProposerAddress,
+    targetCommitteeSize,
+  ] = await Promise.all([
+    rollup.getL1StartBlock(),
+    rollup.getL1GenesisTime(),
+    rollup.getProofSubmissionEpochs(),
+    rollup.getGenesisArchiveTreeRoot(),
+    rollup.getSlashingProposerAddress(),
+    rollup.getTargetCommitteeSize(),
+  ] as const);
 
   const l1StartBlockHash = await publicClient
     .getBlock({ blockNumber: l1StartBlock, includeTransactions: false })
@@ -99,6 +108,7 @@ export async function createArchiver(
     slotDuration,
     ethereumSlotDuration,
     proofSubmissionEpochs: Number(proofSubmissionEpochs),
+    targetCommitteeSize,
     genesisArchiveRoot: Fr.fromString(genesisArchiveRoot.toString()),
   };
 
@@ -119,13 +129,15 @@ export async function createArchiver(
   // Create the event emitter that will be shared by archiver and synchronizer
   const events = new EventEmitter() as ArchiverEmitter;
 
+  // Create L2 tips cache shared by archiver and synchronizer
+  const l2TipsCache = new L2TipsCache(archiverStore.blockStore);
+
   // Create the L1 synchronizer
   const synchronizer = new ArchiverL1Synchronizer(
     publicClient,
     debugClient,
     rollup,
     inbox,
-    { ...config.l1Contracts, slashingProposerAddress },
     archiverStore,
     archiverConfig,
     deps.blobClient,
@@ -135,6 +147,8 @@ export async function createArchiver(
     l1Constants,
     events,
     instrumentation.tracer,
+    l2TipsCache,
+    undefined, // log (use default)
   );
 
   const archiver = new Archiver(
@@ -149,13 +163,15 @@ export async function createArchiver(
     l1Constants,
     synchronizer,
     events,
+    l2TipsCache,
   );
 
   await archiver.start(opts.blockUntilSync);
   return archiver;
 }
 
-async function registerProtocolContracts(store: KVArchiverDataStore) {
+/** Registers protocol contracts in the archiver store. */
+export async function registerProtocolContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   for (const name of protocolContractNames) {
     const provider = new BundledProtocolContractsProvider();

package/src/index.ts

@@ -8,5 +8,6 @@ export * from './config.js';
 export { type L1PublishedData } from './structs/published.js';
 export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './store/kv_archiver_store.js';
 export { ContractInstanceStore } from './store/contract_instance_store.js';
+export { L2TipsCache } from './store/l2_tips_cache.js';
 
 export { retrieveCheckpointsFromRollup, retrieveL2ProofVerifiedEvents } from './l1/data_retrieval.js';

package/src/l1/README.md

@@ -5,29 +5,27 @@ Modules and classes to handle data retrieval from L1 for the archiver.
 ## Calldata Retriever
 
 The sequencer publisher bundles multiple operations into a single multicall3 transaction for gas
-efficiency. A typical transaction includes:
+efficiency. The archiver needs to extract the `propose` calldata from these bundled transactions
+to reconstruct L2 blocks.
 
-1. Attestation invalidations (if needed): `invalidateBadAttestation`, `invalidateInsufficientAttestations`
-2. Block proposal: `propose` (exactly one per transaction to the rollup contract)
-3. Governance and slashing (if needed): votes, payload creation/execution
+The retriever uses hash matching against `attestationsHash` and `payloadDigest` from the
+`CheckpointProposed` L1 event to verify it has found the correct propose calldata. These hashes
+are always required.
 
-The archiver needs to extract the `propose` calldata from these bundled transactions to reconstruct
-L2 blocks. This class needs to handle scenarios where the transaction was submitted via multicall3,
-as well as alternative ways for submitting the `propose` call that other clients might use.
+### Multicall3 Decoding with Hash Matching
 
-### Multicall3 Validation and Decoding
-
-First attempt to decode the transaction as a multicall3 `aggregate3` call with validation:
+First attempt to decode the transaction as a multicall3 `aggregate3` call:
 
 - Check if transaction is to multicall3 address (`0xcA11bde05977b3631167028862bE2a173976CA11`)
 - Decode as `aggregate3(Call3[] calldata calls)`
-- Allow calls to known addresses and methods (rollup, governance, slashing contracts, etc.)
-- Find the single `propose` call to the rollup contract
-- Verify exactly one `propose` call exists
-- Extract and return the propose calldata
+- Find all calls matching the rollup contract address and the `propose` function selector
+- Verify each candidate by computing `attestationsHash` (keccak256 of ABI-encoded attestations)
+  and `payloadDigest` (keccak256 of the consensus payload signing hash) and comparing against
+  expected values from the `CheckpointProposed` event
+- Return the verified candidate (if multiple verify, return the first with a warning)
 
-This step handles the common case efficiently without requiring expensive trace or debug RPC calls.
-Any validation failure triggers fallback to the next step.
+This approach works regardless of what other calls are in the multicall3 bundle, because hash
+matching identifies the correct propose call without needing an allowlist.
 
 ### Direct Propose Call
 
@@ -35,64 +33,23 @@ Second attempt to decode the transaction as a direct `propose` call to the rollu
 
 - Check if transaction is to the rollup address
 - Decode as `propose` function call
-- Verify the function is indeed `propose`
+- Verify against expected hashes
 - Return the transaction input as the propose calldata
 
-This handles scenarios where clients submit transactions directly to the rollup contract without
-using multicall3 for bundling. Any validation failure triggers fallback to the next step.
-
 ### Spire Proposer Call
 
-Given existing attempts to route the call via the Spire proposer, we also check if the tx is `to` the 
-proposer known address, and if so, we try decoding it as either a multicall3 or a direct call to the
-rollup contract.
-
-Similar as with the multicall3 check, we check that there are no other calls in the Spire proposer, so
-we are absolutely sure that the only call is the successful one to the rollup. Any extraneous call would
-imply an unexpected path to calling `propose` in the rollup contract, and since we cannot verify if the
-calldata arguments we extracted are the correct ones (see the section below), we cannot know for sure which
-one is the call that succeeded, so we don't know which calldata to process.
-
-Furthermore, since the Spire proposer is upgradeable, we check if the implementation has not changed in
-order to decode. As usual, any validation failure triggers fallback to the next step.
-
-### Verifying Multicall3 Arguments
-
-**This is NOT implemented for simplicity's sake**
-
-If the checks above don't hold, such as when there are multiple calls to `propose`, then we cannot
-reliably extract the `propose` calldata from the multicall3 arguments alone. We can try a best-effort
-where we try all `propose` calls we see and validate them against on-chain data. Note that we can use these
-same strategies if we were to obtain the calldata from another source.
-
-#### TempBlockLog Verification
-
-Read the stored `TempBlockLog` for the L2 block number from L1 and verify it matches our decoded header hash,
-since the `TempBlockLog` stores the hash of the proposed block header, the payload commitment, and the attestations.
-
-However, `TempBlockLog` is only stored temporarily and deleted after proven, so this method only works for recent
-blocks, not for historical data syncing.
-
-#### Archive Verification
-
-Verify that the archive root in the decoded propose is correct with regard to the block header. This requires
-hashing the block header we have retrieved, inserting it into the archive tree, and checking the resulting root
-against the one we got from L1.
-
-However, this requires that the archive keeps a reference to world-state, which is not the case in the current
-system.
-
-#### Emit Commitments in Rollup Contract
-
-Modify rollup contract to emit commitments to the block header in the `L2BlockProposed` event, allowing us to easily
-verify the calldata we obtained vs the emitted event.
+Given existing attempts to route the call via the Spire proposer, we also check if the tx is
+`to` the proposer known address. If so, we extract all wrapped calls and try each as either
+a multicall3 or direct propose call, using hash matching to find and verify the correct one.
 
-However, modifying the rollup contract is out of scope for this change. But we can implement this approach in `v2`.
+Since the Spire proposer is upgradeable, we check that the implementation has not changed in
+order to decode. Any validation failure triggers fallback to the next step.
 
 ### Debug and Trace Transaction Fallback
 
-Last, we use L1 node's trace/debug RPC methods to definitively identify the one successful `propose` call within the tx.
-We can then extract the exact calldata that hit the `propose` function in the rollup contract.
+Last, we use L1 node's trace/debug RPC methods to definitively identify the one successful
+`propose` call within the tx. We can then extract the exact calldata that hit the `propose`
+function in the rollup contract.
 
-This approach requires access to a debug-enabled L1 node, which may be more resource-intensive, so we only
-use it as a fallback when the first step fails, which should be rare in practice.
+This approach requires access to a debug-enabled L1 node, which may be more resource-intensive,
+so we only use it as a fallback when earlier steps fail, which should be rare in practice.