@aztec/archiver 3.0.0-nightly.20251214 → 3.0.0-nightly.20251217

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -6,7 +6,8 @@ import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type L2Block, L2BlockHash, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateBlockResult } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
   ContractDataSource,
@@ -24,14 +25,13 @@ import { join } from 'path';
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import type { InboxMessage } from '../structs/inbox_message.js';
-import type { PublishedL2Block } from '../structs/published.js';
-import { BlockStore } from './block_store.js';
+import { BlockStore, type CheckpointData } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
 import { MessageStore } from './message_store.js';
 
-export const ARCHIVER_DB_VERSION = 4;
+export const ARCHIVER_DB_VERSION = 5;
 export const MAX_FUNCTION_SIGNATURES = 1000;
 export const MAX_FUNCTION_NAME_LEN = 256;
 
@@ -67,7 +67,7 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
   }
 
   public getBlockNumber(): Promise<BlockNumber> {
-    return this.getSynchedL2BlockNumber();
+    return this.#blockStore.getLatestL2BlockNumber();
   }
 
   public async getContract(
@@ -186,42 +186,52 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: PublishedL2Block[], opts: { force?: boolean } = {}): Promise<boolean> {
+  addBlocks(blocks: L2BlockNew[], opts: { force?: boolean; checkpointNumber?: number } = {}): Promise<boolean> {
     return this.#blockStore.addBlocks(blocks, opts);
   }
 
+  getRangeOfCheckpoints(from: CheckpointNumber, limit: number): Promise<CheckpointData[]> {
+    return this.#blockStore.getRangeOfCheckpoints(from, limit);
+  }
+  getLatestBlockNumber(): Promise<BlockNumber> {
+    return this.#blockStore.getLatestBlockNumber();
+  }
+
   /**
-   * Unwinds blocks from the database
+   * Unwinds checkpoints from the database
    * @param from -  The tip of the chain, passed for verification purposes,
    *                ensuring that we don't end up deleting something we did not intend
-   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @param checkpointsToUnwind - The number of checkpoints we are to unwind
    * @returns True if the operation is successful
    */
-  unwindBlocks(from: BlockNumber, blocksToUnwind: number): Promise<boolean> {
-    return this.#blockStore.unwindBlocks(from, blocksToUnwind);
+  unwindCheckpoints(from: CheckpointNumber, checkpointsToUnwind: number): Promise<boolean> {
+    return this.#blockStore.unwindCheckpoints(from, checkpointsToUnwind);
   }
 
-  getPublishedBlock(number: BlockNumber): Promise<PublishedL2Block | undefined> {
-    return this.#blockStore.getBlock(number);
+  addCheckpoints(checkpoints: PublishedCheckpoint[]): Promise<boolean> {
+    return this.#blockStore.addCheckpoints(checkpoints);
   }
 
-  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
+    return this.#blockStore.getCheckpointedBlock(number);
+  }
+  getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
+    return this.#blockStore.getCheckpointedBlockByHash(blockHash);
+  }
+  getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
+    return this.#blockStore.getCheckpointedBlockByArchive(archive);
+  }
+  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
+    return this.#blockStore.getBlock(number);
+  }
+  getBlockByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
   }
-
-  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+  getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByArchive(archive);
   }
-
-  /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   *
-   * @param start - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks
-   */
-  getPublishedBlocks(start: BlockNumber, limit: number): Promise<PublishedL2Block[]> {
-    return toArray(this.#blockStore.getBlocks(start, limit));
+  getBlocks(from: BlockNumber, limit: BlockNumber): Promise<L2BlockNew[]> {
+    return toArray(this.#blockStore.getBlocks(from, limit));
   }
 
   /**
@@ -266,11 +276,11 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.addLogs(blocks);
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.deleteLogs(blocks);
   }
 
@@ -349,20 +359,12 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     }
   }
 
-  /**
-   * Gets the number of the latest L2 block processed.
-   * @returns The number of the latest L2 block processed.
-   */
-  getSynchedL2BlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getSynchedL2BlockNumber();
-  }
-
-  getProvenL2BlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getProvenL2BlockNumber();
+  getProvenCheckpointNumber(): Promise<CheckpointNumber> {
+    return this.#blockStore.getProvenCheckpointNumber();
   }
 
-  async setProvenL2BlockNumber(blockNumber: BlockNumber) {
-    await this.#blockStore.setProvenL2BlockNumber(blockNumber);
+  async setProvenCheckpointNumber(checkpointNumber: CheckpointNumber) {
+    await this.#blockStore.setProvenCheckpointNumber(checkpointNumber);
   }
 
   async setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
@@ -373,6 +375,10 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     await this.#messageStore.setSynchedL1Block(l1Block);
   }
 
+  getProvenBlockNumber(): Promise<BlockNumber> {
+    return this.#blockStore.getProvenBlockNumber();
+  }
+
   /**
    * Gets the last L1 block number processed by the archiver
    */
@@ -410,4 +416,22 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
   public setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
     return this.#blockStore.setPendingChainValidationStatus(status);
   }
+
+  public getCheckpointedL2BlockNumber(): Promise<BlockNumber> {
+    return this.#blockStore.getCheckpointedL2BlockNumber();
+  }
+  public getSynchedCheckpointNumber(): Promise<CheckpointNumber> {
+    return this.#blockStore.getLatestCheckpointNumber();
+  }
+  async setCheckpointSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
+    await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
+  }
+
+  getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
+    return this.#blockStore.getBlocksForCheckpoint(checkpointNumber);
+  }
+
+  getCheckpointData(checkpointNumber: CheckpointNumber): Promise<CheckpointData | undefined> {
+    return this.#blockStore.getCheckpointData(checkpointNumber);
+  }
 }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,10 +1,10 @@
 import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/curves/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { L2Block } from '@aztec/stdlib/block';
+import { L2BlockHash, L2BlockNew } from '@aztec/stdlib/block';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import {
   ContractClassLog,
@@ -42,7 +42,8 @@ export class LogStore {
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
-  #extractTaggedLogs(block: L2Block) {
+  async #extractTaggedLogs(block: L2BlockNew) {
+    const blockHash = L2BlockHash.fromField(await block.hash());
     const taggedLogs = new Map<string, Buffer[]>();
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
@@ -56,7 +57,9 @@ export class LogStore {
         this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
 
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, log).toBuffer());
+        currentLogs.push(
+          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, blockHash, log).toBuffer(),
+        );
         taggedLogs.set(tag.toString(), currentLogs);
       });
 
@@ -65,7 +68,9 @@ export class LogStore {
         this.#log.debug(`Found public log with tag ${tag.toString()} in block ${block.number}`);
 
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, log).toBuffer());
+        currentLogs.push(
+          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, blockHash, log).toBuffer(),
+        );
         taggedLogs.set(tag.toString(), currentLogs);
       });
     });
@@ -77,16 +82,15 @@ export class LogStore {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
-    const taggedLogsToAdd = blocks
-      .map(block => this.#extractTaggedLogs(block))
-      .reduce((acc, val) => {
-        for (const [tag, logs] of val.entries()) {
-          const currentLogs = acc.get(tag) ?? [];
-          acc.set(tag, currentLogs.concat(logs));
-        }
-        return acc;
-      }, new Map());
+  async addLogs(blocks: L2BlockNew[]): Promise<boolean> {
+    const taggedLogsInBlocks = await Promise.all(blocks.map(block => this.#extractTaggedLogs(block)));
+    const taggedLogsToAdd = taggedLogsInBlocks.reduce((acc, taggedLogs) => {
+      for (const [tag, logs] of taggedLogs.entries()) {
+        const currentLogs = acc.get(tag) ?? [];
+        acc.set(tag, currentLogs.concat(logs));
+      }
+      return acc;
+    }, new Map<string, Buffer[]>());
     const tagsToUpdate = Array.from(taggedLogsToAdd.keys());
 
     return this.db.transactionAsync(async () => {
@@ -102,6 +106,8 @@ export class LogStore {
         }
       });
       for (const block of blocks) {
+        const blockHash = await block.hash();
+
         const tagsInBlock = [];
         for (const [tag, logs] of taggedLogsToAdd.entries()) {
           await this.#logsByTag.set(tag, logs);
@@ -129,15 +135,32 @@ export class LogStore {
           )
           .flat();
 
-        await this.#publicLogsByBlock.set(block.number, Buffer.concat(publicLogsInBlock));
-        await this.#contractClassLogsByBlock.set(block.number, Buffer.concat(contractClassLogsInBlock));
+        await this.#publicLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, publicLogsInBlock));
+        await this.#contractClassLogsByBlock.set(
+          block.number,
+          this.#packWithBlockHash(blockHash, contractClassLogsInBlock),
+        );
       }
 
       return true;
     });
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  #packWithBlockHash(blockHash: Fr, data: Buffer<ArrayBufferLike>[]): Buffer<ArrayBufferLike> {
+    return Buffer.concat([blockHash.toBuffer(), ...data]);
+  }
+
+  #unpackBlockHash(reader: BufferReader): L2BlockHash {
+    const blockHash = reader.remainingBytes() > 0 ? reader.readObject(Fr) : undefined;
+
+    if (!blockHash) {
+      throw new Error('Failed to read block hash from log entry buffer');
+    }
+
+    return L2BlockHash.fromField(blockHash);
+  }
+
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
       const tagsToDelete = (
         await Promise.all(
@@ -207,6 +230,9 @@ export class LogStore {
     const buffer = (await this.#publicLogsByBlock.getAsync(blockNumber)) ?? Buffer.alloc(0);
     const publicLogsInBlock: [PublicLog[]] = [[]];
     const reader = new BufferReader(buffer);
+
+    const blockHash = this.#unpackBlockHash(reader);
+
     while (reader.remainingBytes() > 0) {
       const indexOfTx = reader.readNumber();
       const numLogsInTx = reader.readNumber();
@@ -219,7 +245,7 @@ export class LogStore {
     const txLogs = publicLogsInBlock[txIndex];
 
     const logs: ExtendedPublicLog[] = [];
-    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
 
     return { logs, maxLogsHit };
   }
@@ -242,6 +268,9 @@ export class LogStore {
     loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#publicLogsByBlock.entriesAsync({ start, end })) {
       const publicLogsInBlock: [PublicLog[]] = [[]];
       const reader = new BufferReader(logBuffer);
+
+      const blockHash = this.#unpackBlockHash(reader);
+
       while (reader.remainingBytes() > 0) {
         const indexOfTx = reader.readNumber();
         const numLogsInTx = reader.readNumber();
@@ -252,7 +281,7 @@ export class LogStore {
       }
       for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < publicLogsInBlock.length; txIndex++) {
         const txLogs = publicLogsInBlock[txIndex];
-        maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         if (maxLogsHit) {
           this.#log.debug(`Max logs hit at block ${blockNumber}`);
           break loopOverBlocks;
@@ -291,6 +320,8 @@ export class LogStore {
     const contractClassLogsInBlock: [ContractClassLog[]] = [[]];
 
     const reader = new BufferReader(contractClassLogsBuffer);
+    const blockHash = this.#unpackBlockHash(reader);
+
     while (reader.remainingBytes() > 0) {
       const indexOfTx = reader.readNumber();
       const numLogsInTx = reader.readNumber();
@@ -303,7 +334,7 @@ export class LogStore {
     const txLogs = contractClassLogsInBlock[txIndex];
 
     const logs: ExtendedContractClassLog[] = [];
-    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
 
     return { logs, maxLogsHit };
   }
@@ -329,6 +360,7 @@ export class LogStore {
     })) {
       const contractClassLogsInBlock: [ContractClassLog[]] = [[]];
       const reader = new BufferReader(logBuffer);
+      const blockHash = this.#unpackBlockHash(reader);
       while (reader.remainingBytes() > 0) {
         const indexOfTx = reader.readNumber();
         const numLogsInTx = reader.readNumber();
@@ -339,7 +371,7 @@ export class LogStore {
       }
       for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < contractClassLogsInBlock.length; txIndex++) {
         const txLogs = contractClassLogsInBlock[txIndex];
-        maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         if (maxLogsHit) {
           this.#log.debug(`Max logs hit at block ${blockNumber}`);
           break loopOverBlocks;
@@ -353,9 +385,10 @@ export class LogStore {
   #accumulateLogs(
     results: (ExtendedContractClassLog | ExtendedPublicLog)[],
     blockNumber: number,
+    blockHash: L2BlockHash,
     txIndex: number,
     txLogs: (ContractClassLog | PublicLog)[],
-    filter: LogFilter,
+    filter: LogFilter = {},
   ): boolean {
     let maxLogsHit = false;
     let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0;
@@ -363,9 +396,13 @@ export class LogStore {
       const log = txLogs[logIndex];
       if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
         if (log instanceof ContractClassLog) {
-          results.push(new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), txIndex, logIndex), log));
+          results.push(
+            new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log),
+          );
+        } else if (log instanceof PublicLog) {
+          results.push(new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log));
         } else {
-          results.push(new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), txIndex, logIndex), log));
+          throw new Error('Unknown log type');
         }
 
         if (results.length >= this.#logsMaxPageSize) {

package/src/archiver/l1/bin/retrieve-calldata.ts

@@ -141,8 +141,8 @@ async function main() {
     logger.info('Retrieving block header from rollup transaction...');
     logger.info('');
 
-    // For this script, we don't have blob hashes, so pass empty array
-    const result = await retriever.getCheckpointFromRollupTx(txHash, [], CheckpointNumber(l2BlockNumber));
+    // For this script, we don't have blob hashes or expected hashes, so pass empty arrays/objects
+    const result = await retriever.getCheckpointFromRollupTx(txHash, [], CheckpointNumber(l2BlockNumber), {});
 
     logger.info(' Successfully retrieved block header!');
     logger.info('');

package/src/archiver/l1/calldata_retriever.ts

@@ -13,9 +13,20 @@ import {
   TallySlashingProposerAbi,
 } from '@aztec/l1-artifacts';
 import { CommitteeAttestation } from '@aztec/stdlib/block';
+import { ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 
-import { type Hex, type Transaction, decodeFunctionData, hexToBytes, multicall3Abi, toFunctionSelector } from 'viem';
+import {
+  type AbiParameter,
+  type Hex,
+  type Transaction,
+  decodeFunctionData,
+  encodeAbiParameters,
+  hexToBytes,
+  keccak256,
+  multicall3Abi,
+  toFunctionSelector,
+} from 'viem';
 
 import type { ArchiverInstrumentation } from '../instrumentation.js';
 import { getSuccessfulCallsFromDebug } from './debug_tx.js';
@@ -56,12 +67,17 @@ export class CalldataRetriever {
    * @param txHash - Hash of the tx that published it.
    * @param blobHashes - Blob hashes for the checkpoint.
    * @param checkpointNumber - Checkpoint number.
+   * @param expectedHashes - Optional expected hashes from the CheckpointProposed event for validation
    * @returns Checkpoint header and metadata from the calldata, deserialized
    */
   async getCheckpointFromRollupTx(
     txHash: `0x${string}`,
     blobHashes: Buffer[],
     checkpointNumber: CheckpointNumber,
+    expectedHashes: {
+      attestationsHash?: Hex;
+      payloadDigest?: Hex;
+    },
   ): Promise<{
     checkpointNumber: CheckpointNumber;
     archiveRoot: Fr;
@@ -69,10 +85,14 @@ export class CalldataRetriever {
     attestations: CommitteeAttestation[];
     blockHash: string;
   }> {
-    this.logger.trace(`Fetching checkpoint ${checkpointNumber} from rollup tx ${txHash}`);
+    this.logger.trace(`Fetching checkpoint ${checkpointNumber} from rollup tx ${txHash}`, {
+      willValidateHashes: !!expectedHashes.attestationsHash || !!expectedHashes.payloadDigest,
+      hasAttestationsHash: !!expectedHashes.attestationsHash,
+      hasPayloadDigest: !!expectedHashes.payloadDigest,
+    });
     const tx = await this.publicClient.getTransaction({ hash: txHash });
     const proposeCalldata = await this.getProposeCallData(tx, checkpointNumber);
-    return this.decodeAndBuildCheckpoint(proposeCalldata, tx.blockHash!, checkpointNumber);
+    return this.decodeAndBuildCheckpoint(proposeCalldata, tx.blockHash!, checkpointNumber, expectedHashes);
   }
 
   /** Gets rollup propose calldata from a transaction */
@@ -324,17 +344,59 @@ export class CalldataRetriever {
     return calls[0].input;
   }
 
+  /**
+   * Extracts the CommitteeAttestations struct definition from RollupAbi.
+   * Finds the _attestations parameter by name in the propose function.
+   * Lazy-loaded to avoid issues during module initialization.
+   */
+  private getCommitteeAttestationsStructDef(): AbiParameter {
+    const proposeFunction = RollupAbi.find(item => item.type === 'function' && item.name === 'propose') as
+      | { type: 'function'; name: string; inputs: readonly AbiParameter[] }
+      | undefined;
+
+    if (!proposeFunction) {
+      throw new Error('propose function not found in RollupAbi');
+    }
+
+    // Find the _attestations parameter by name, not by index
+    const attestationsParam = proposeFunction.inputs.find(param => param.name === '_attestations');
+
+    if (!attestationsParam) {
+      throw new Error('_attestations parameter not found in propose function');
+    }
+
+    if (attestationsParam.type !== 'tuple') {
+      throw new Error(`Expected _attestations parameter to be a tuple, got ${attestationsParam.type}`);
+    }
+
+    // Extract the tuple components (struct fields)
+    const tupleParam = attestationsParam as unknown as {
+      type: 'tuple';
+      components?: readonly AbiParameter[];
+    };
+
+    return {
+      type: 'tuple',
+      components: tupleParam.components || [],
+    } as AbiParameter;
+  }
+
   /**
    * Decodes propose calldata and builds the checkpoint header structure.
    * @param proposeCalldata - The propose function calldata
    * @param blockHash - The L1 block hash containing this transaction
    * @param checkpointNumber - The checkpoint number
+   * @param expectedHashes - Optional expected hashes from the CheckpointProposed event for validation
    * @returns The decoded checkpoint header and metadata
    */
   protected decodeAndBuildCheckpoint(
     proposeCalldata: Hex,
     blockHash: Hex,
     checkpointNumber: CheckpointNumber,
+    expectedHashes: {
+      attestationsHash?: Hex;
+      payloadDigest?: Hex;
+    },
   ): {
     checkpointNumber: CheckpointNumber;
     archiveRoot: Fr;
@@ -365,6 +427,57 @@ export class CalldataRetriever {
       ];
 
     const attestations = CommitteeAttestation.fromPacked(packedAttestations, this.targetCommitteeSize);
+    const header = CheckpointHeader.fromViem(decodedArgs.header);
+    const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
+
+    // Validate attestationsHash if provided (skip for backwards compatibility with older events)
+    if (expectedHashes.attestationsHash) {
+      // Compute attestationsHash: keccak256(abi.encode(CommitteeAttestations))
+      const computedAttestationsHash = keccak256(
+        encodeAbiParameters([this.getCommitteeAttestationsStructDef()], [packedAttestations]),
+      );
+
+      // Compare as buffers to avoid case-sensitivity and string comparison issues
+      const computedBuffer = Buffer.from(hexToBytes(computedAttestationsHash));
+      const expectedBuffer = Buffer.from(hexToBytes(expectedHashes.attestationsHash));
+
+      if (!computedBuffer.equals(expectedBuffer)) {
+        throw new Error(
+          `Attestations hash mismatch for checkpoint ${checkpointNumber}: ` +
+            `computed=${computedAttestationsHash}, expected=${expectedHashes.attestationsHash}`,
+        );
+      }
+
+      this.logger.trace(`Validated attestationsHash for checkpoint ${checkpointNumber}`, {
+        computedAttestationsHash,
+        expectedAttestationsHash: expectedHashes.attestationsHash,
+      });
+    }
+
+    // Validate payloadDigest if provided (skip for backwards compatibility with older events)
+    if (expectedHashes.payloadDigest) {
+      // Use ConsensusPayload to compute the digest - this ensures we match the exact logic
+      // used by the network for signing and verification
+      const consensusPayload = new ConsensusPayload(header, archiveRoot);
+      const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
+      const computedPayloadDigest = keccak256(payloadToSign);
+
+      // Compare as buffers to avoid case-sensitivity and string comparison issues
+      const computedBuffer = Buffer.from(hexToBytes(computedPayloadDigest));
+      const expectedBuffer = Buffer.from(hexToBytes(expectedHashes.payloadDigest));
+
+      if (!computedBuffer.equals(expectedBuffer)) {
+        throw new Error(
+          `Payload digest mismatch for checkpoint ${checkpointNumber}: ` +
+            `computed=${computedPayloadDigest}, expected=${expectedHashes.payloadDigest}`,
+        );
+      }
+
+      this.logger.trace(`Validated payloadDigest for checkpoint ${checkpointNumber}`, {
+        computedPayloadDigest,
+        expectedPayloadDigest: expectedHashes.payloadDigest,
+      });
+    }
 
     this.logger.trace(`Decoded propose calldata`, {
       checkpointNumber,
@@ -376,9 +489,6 @@ export class CalldataRetriever {
       targetCommitteeSize: this.targetCommitteeSize,
     });
 
-    const header = CheckpointHeader.fromViem(decodedArgs.header);
-    const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
-
     return {
       checkpointNumber,
       archiveRoot,