@aztec/archiver 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/archiver/{data_retrieval.ts → l1/data_retrieval.ts}

@@ -1,23 +1,26 @@
-import { Blob, BlobDeserializationError } from '@aztec/blob-lib';
+import {
+  BlobDeserializationError,
+  type CheckpointBlobData,
+  SpongeBlob,
+  decodeCheckpointBlobDataFromBlobs,
+  encodeBlockBlobData,
+} from '@aztec/blob-lib';
 import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type {
-  EpochProofPublicInputArgs,
-  ViemClient,
-  ViemCommitteeAttestations,
-  ViemHeader,
-  ViemPublicClient,
-  ViemStateReference,
-} from '@aztec/ethereum';
+import type { EpochProofPublicInputArgs } from '@aztec/ethereum/contracts';
+import type { ViemClient, ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { asyncPool } from '@aztec/foundation/async-pool';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { Body, CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { Proof } from '@aztec/stdlib/proofs';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader, GlobalVariables, ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
+import { BlockHeader, GlobalVariables, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
 
 import {
   type GetContractEventsReturnType,
@@ -26,91 +29,139 @@ import {
   decodeFunctionData,
   getAbiItem,
   hexToBytes,
-  multicall3Abi,
 } from 'viem';
 
-import { NoBlobBodiesFoundError } from './errors.js';
-import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { InboxMessage } from './structs/inbox_message.js';
-import type { L1PublishedData, PublishedL2Block } from './structs/published.js';
+import { NoBlobBodiesFoundError } from '../errors.js';
+import type { ArchiverInstrumentation } from '../instrumentation.js';
+import type { DataRetrieval } from '../structs/data_retrieval.js';
+import type { InboxMessage } from '../structs/inbox_message.js';
+import type { L1PublishedData } from '../structs/published.js';
+import { CalldataRetriever } from './calldata_retriever.js';
 
-export type RetrievedL2Block = {
-  l2BlockNumber: number;
+export type RetrievedCheckpoint = {
+  checkpointNumber: CheckpointNumber;
   archiveRoot: Fr;
-  stateReference: StateReference;
-  header: ProposedBlockHeader;
-  body: Body;
+  header: CheckpointHeader;
+  checkpointBlobData: CheckpointBlobData;
   l1: L1PublishedData;
   chainId: Fr;
   version: Fr;
   attestations: CommitteeAttestation[];
 };
 
-export function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Block): PublishedL2Block {
-  const {
-    l2BlockNumber,
-    archiveRoot,
-    stateReference,
-    header: proposedHeader,
-    body,
-    l1,
-    chainId,
-    version,
-    attestations,
-  } = retrievedBlock;
-
-  const archive = new AppendOnlyTreeSnapshot(
-    archiveRoot,
-    l2BlockNumber + 1, // nextAvailableLeafIndex
-  );
-
-  const globalVariables = GlobalVariables.from({
-    chainId,
-    version,
-    blockNumber: l2BlockNumber,
-    slotNumber: proposedHeader.slotNumber,
-    timestamp: proposedHeader.timestamp,
-    coinbase: proposedHeader.coinbase,
-    feeRecipient: proposedHeader.feeRecipient,
-    gasFees: proposedHeader.gasFees,
-  });
+export async function retrievedToPublishedCheckpoint({
+  checkpointNumber,
+  archiveRoot,
+  header: checkpointHeader,
+  checkpointBlobData,
+  l1,
+  chainId,
+  version,
+  attestations,
+}: RetrievedCheckpoint): Promise<PublishedCheckpoint> {
+  const { blocks: blocksBlobData } = checkpointBlobData;
+
+  // The lastArchiveRoot of a block is the new archive for the previous block.
+  const newArchiveRoots = blocksBlobData
+    .map(b => b.lastArchiveRoot)
+    .slice(1)
+    .concat([archiveRoot]);
+
+  // An error will be thrown from `decodeCheckpointBlobDataFromBlobs` if it can't read a field for the
+  // `l1ToL2MessageRoot` of the first block. So below we can safely assume it exists:
+  const l1toL2MessageTreeRoot = blocksBlobData[0].l1ToL2MessageRoot!;
+
+  const spongeBlob = SpongeBlob.init();
+  const l2Blocks: L2BlockNew[] = [];
+  for (let i = 0; i < blocksBlobData.length; i++) {
+    const blockBlobData = blocksBlobData[i];
+    const { blockEndMarker, blockEndStateField, lastArchiveRoot, noteHashRoot, nullifierRoot, publicDataRoot } =
+      blockBlobData;
+
+    const l2BlockNumber = blockEndMarker.blockNumber;
+
+    const globalVariables = GlobalVariables.from({
+      chainId,
+      version,
+      blockNumber: l2BlockNumber,
+      slotNumber: checkpointHeader.slotNumber,
+      timestamp: blockEndMarker.timestamp,
+      coinbase: checkpointHeader.coinbase,
+      feeRecipient: checkpointHeader.feeRecipient,
+      gasFees: checkpointHeader.gasFees,
+    });
+
+    const state = StateReference.from({
+      l1ToL2MessageTree: new AppendOnlyTreeSnapshot(
+        l1toL2MessageTreeRoot,
+        blockEndStateField.l1ToL2MessageNextAvailableLeafIndex,
+      ),
+      partial: PartialStateReference.from({
+        noteHashTree: new AppendOnlyTreeSnapshot(noteHashRoot, blockEndStateField.noteHashNextAvailableLeafIndex),
+        nullifierTree: new AppendOnlyTreeSnapshot(nullifierRoot, blockEndStateField.nullifierNextAvailableLeafIndex),
+        publicDataTree: new AppendOnlyTreeSnapshot(publicDataRoot, blockEndStateField.publicDataNextAvailableLeafIndex),
+      }),
+    });
+
+    const body = Body.fromTxBlobData(checkpointBlobData.blocks[0].txs);
+
+    const blobFields = encodeBlockBlobData(blockBlobData);
+    await spongeBlob.absorb(blobFields);
+
+    const clonedSpongeBlob = spongeBlob.clone();
+    const spongeBlobHash = await clonedSpongeBlob.squeeze();
+
+    const header = BlockHeader.from({
+      lastArchive: new AppendOnlyTreeSnapshot(lastArchiveRoot, l2BlockNumber),
+      state,
+      spongeBlobHash,
+      globalVariables,
+      totalFees: body.txEffects.reduce((accum, txEffect) => accum.add(txEffect.transactionFee), Fr.ZERO),
+      totalManaUsed: new Fr(blockEndStateField.totalManaUsed),
+    });
+
+    const newArchive = new AppendOnlyTreeSnapshot(newArchiveRoots[i], l2BlockNumber + 1);
+
+    l2Blocks.push(new L2BlockNew(newArchive, header, body, checkpointNumber, i));
+  }
 
-  const header = BlockHeader.from({
-    lastArchive: new AppendOnlyTreeSnapshot(proposedHeader.lastArchiveRoot, l2BlockNumber),
-    contentCommitment: proposedHeader.contentCommitment,
-    state: stateReference,
-    globalVariables,
-    totalFees: body.txEffects.reduce((accum, txEffect) => accum.add(txEffect.transactionFee), Fr.ZERO),
-    totalManaUsed: proposedHeader.totalManaUsed,
+  const lastBlock = l2Blocks.at(-1)!;
+  const checkpoint = Checkpoint.from({
+    archive: new AppendOnlyTreeSnapshot(archiveRoot, lastBlock.number + 1),
+    header: checkpointHeader,
+    blocks: l2Blocks,
+    number: checkpointNumber,
   });
 
-  const block = new L2Block(archive, header, body);
-
-  return {
-    block,
-    l1,
-    attestations,
-  };
+  return PublishedCheckpoint.from({ checkpoint, l1, attestations });
 }
 
 /**
- * Fetches new L2 blocks.
+ * Fetches new checkpoints.
  * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
  * @param rollupAddress - The address of the rollup contract.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
  * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
  * @returns An array of block; as well as the next eth block to search from.
  */
-export async function retrieveBlocksFromRollup(
+export async function retrieveCheckpointsFromRollup(
   rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
   publicClient: ViemPublicClient,
+  debugClient: ViemPublicDebugClient,
   blobSinkClient: BlobSinkClientInterface,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
+  contractAddresses: {
+    governanceProposerAddress: EthAddress;
+    slashFactoryAddress?: EthAddress;
+    slashingProposerAddress: EthAddress;
+  },
+  instrumentation: ArchiverInstrumentation,
   logger: Logger = createLogger('archiver'),
-): Promise<RetrievedL2Block[]> {
-  const retrievedBlocks: RetrievedL2Block[] = [];
+): Promise<RetrievedCheckpoint[]> {
+  const retrievedCheckpoints: RetrievedCheckpoint[] = [];
 
   let rollupConstants: { chainId: Fr; version: Fr; targetCommitteeSize: number } | undefined;
 
@@ -118,8 +169,8 @@ export async function retrieveBlocksFromRollup(
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const l2BlockProposedLogs = (
-      await rollup.getEvents.L2BlockProposed(
+    const checkpointProposedLogs = (
+      await rollup.getEvents.CheckpointProposed(
         {},
         {
           fromBlock: searchStartBlock,
@@ -128,13 +179,13 @@ export async function retrieveBlocksFromRollup(
       )
     ).filter(log => log.blockNumber! >= searchStartBlock && log.blockNumber! <= searchEndBlock);
 
-    if (l2BlockProposedLogs.length === 0) {
+    if (checkpointProposedLogs.length === 0) {
       break;
     }
 
-    const lastLog = l2BlockProposedLogs[l2BlockProposedLogs.length - 1];
+    const lastLog = checkpointProposedLogs.at(-1)!;
     logger.debug(
-      `Got ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
+      `Got ${checkpointProposedLogs.length} processed logs for checkpoints  ${checkpointProposedLogs[0].args.checkpointNumber}-${lastLog.args.checkpointNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
     );
 
     if (rollupConstants === undefined) {
@@ -150,54 +201,76 @@ export async function retrieveBlocksFromRollup(
       };
     }
 
-    const newBlocks = await processL2BlockProposedLogs(
+    const newCheckpoints = await processCheckpointProposedLogs(
       rollup,
       publicClient,
+      debugClient,
       blobSinkClient,
-      l2BlockProposedLogs,
+      checkpointProposedLogs,
       rollupConstants,
+      contractAddresses,
+      instrumentation,
       logger,
     );
-    retrievedBlocks.push(...newBlocks);
+    retrievedCheckpoints.push(...newCheckpoints);
     searchStartBlock = lastLog.blockNumber! + 1n;
   } while (searchStartBlock <= searchEndBlock);
 
-  // The asyncpool from processL2BlockProposedLogs will not necessarily return the blocks in order, so we sort them before returning.
-  return retrievedBlocks.sort((a, b) => Number(a.l1.blockNumber - b.l1.blockNumber));
+  // The asyncPool from processCheckpointProposedLogs will not necessarily return the checkpoints in order, so we sort them before returning.
+  return retrievedCheckpoints.sort((a, b) => Number(a.l1.blockNumber - b.l1.blockNumber));
 }
 
 /**
- * Processes newly received L2BlockProposed logs.
+ * Processes newly received CheckpointProposed logs.
  * @param rollup - The rollup contract
  * @param publicClient - The viem public client to use for transaction retrieval.
- * @param logs - L2BlockProposed logs.
- * @returns - An array blocks.
+ * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
+ * @param logs - CheckpointProposed logs.
+ * @returns - An array of checkpoints.
  */
-async function processL2BlockProposedLogs(
+async function processCheckpointProposedLogs(
   rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
   publicClient: ViemPublicClient,
+  debugClient: ViemPublicDebugClient,
   blobSinkClient: BlobSinkClientInterface,
-  logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
+  logs: GetContractEventsReturnType<typeof RollupAbi, 'CheckpointProposed'>,
   { chainId, version, targetCommitteeSize }: { chainId: Fr; version: Fr; targetCommitteeSize: number },
+  contractAddresses: {
+    governanceProposerAddress: EthAddress;
+    slashFactoryAddress?: EthAddress;
+    slashingProposerAddress: EthAddress;
+  },
+  instrumentation: ArchiverInstrumentation,
   logger: Logger,
-): Promise<RetrievedL2Block[]> {
-  const retrievedBlocks: RetrievedL2Block[] = [];
+): Promise<RetrievedCheckpoint[]> {
+  const retrievedCheckpoints: RetrievedCheckpoint[] = [];
+  const calldataRetriever = new CalldataRetriever(
+    publicClient,
+    debugClient,
+    targetCommitteeSize,
+    instrumentation,
+    logger,
+    { ...contractAddresses, rollupAddress: EthAddress.fromString(rollup.address) },
+  );
+
   await asyncPool(10, logs, async log => {
-    const l2BlockNumber = Number(log.args.blockNumber!);
+    const checkpointNumber = CheckpointNumber.fromBigInt(log.args.checkpointNumber!);
     const archive = log.args.archive!;
-    const archiveFromChain = await rollup.read.archiveAt([BigInt(l2BlockNumber)]);
+    const archiveFromChain = await rollup.read.archiveAt([BigInt(checkpointNumber)]);
     const blobHashes = log.args.versionedBlobHashes!.map(blobHash => Buffer.from(blobHash.slice(2), 'hex'));
 
-    // The value from the event and contract will match only if the block is in the chain.
+    // The value from the event and contract will match only if the checkpoint is in the chain.
     if (archive === archiveFromChain) {
-      const block = await getBlockFromRollupTx(
-        publicClient,
-        blobSinkClient,
+      const checkpoint = await calldataRetriever.getCheckpointFromRollupTx(
         log.transactionHash!,
         blobHashes,
-        l2BlockNumber,
-        rollup.address,
-        targetCommitteeSize,
+        checkpointNumber,
+      );
+      const checkpointBlobData = await getCheckpointBlobDataFromBlobs(
+        blobSinkClient,
+        checkpoint.blockHash,
+        blobHashes,
+        checkpointNumber,
         logger,
       );
 
@@ -207,22 +280,22 @@ async function processL2BlockProposedLogs(
         timestamp: await getL1BlockTime(publicClient, log.blockNumber),
       };
 
-      retrievedBlocks.push({ ...block, l1, chainId, version });
-      logger.trace(`Retrieved L2 block ${l2BlockNumber} from L1 tx ${log.transactionHash}`, {
+      retrievedCheckpoints.push({ ...checkpoint, checkpointBlobData, l1, chainId, version });
+      logger.trace(`Retrieved checkpoint ${checkpointNumber} from L1 tx ${log.transactionHash}`, {
         l1BlockNumber: log.blockNumber,
-        l2BlockNumber,
+        checkpointNumber,
         archive: archive.toString(),
-        attestations: block.attestations,
+        attestations: checkpoint.attestations,
       });
     } else {
-      logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
+      logger.warn(`Ignoring checkpoint ${checkpointNumber} due to archive root mismatch`, {
         actual: archive,
         expected: archiveFromChain,
       });
     }
   });
 
-  return retrievedBlocks;
+  return retrievedCheckpoints;
 }
 
 export async function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint> {
@@ -230,150 +303,33 @@ export async function getL1BlockTime(publicClient: ViemPublicClient, blockNumber
   return block.timestamp;
 }
 
-/**
- * Extracts the first 'propose' method calldata from a multicall3 transaction's data.
- * @param multicall3Data - The multicall3 transaction input data
- * @param rollupAddress - The address of the rollup contract
- * @returns The calldata for the first 'propose' method call to the rollup contract
- */
-function extractRollupProposeCalldata(multicall3Data: Hex, rollupAddress: Hex): Hex {
-  const { functionName: multicall3FunctionName, args: multicall3Args } = decodeFunctionData({
-    abi: multicall3Abi,
-    data: multicall3Data,
-  });
-
-  if (multicall3FunctionName !== 'aggregate3') {
-    throw new Error(`Unexpected multicall3 method called ${multicall3FunctionName}`);
-  }
-
-  if (multicall3Args.length !== 1) {
-    throw new Error(`Unexpected number of arguments for multicall3`);
-  }
-
-  const [calls] = multicall3Args;
-
-  // Find all rollup calls
-  const rollupAddressLower = rollupAddress.toLowerCase();
-
-  for (let i = 0; i < calls.length; i++) {
-    const addr = calls[i].target;
-    if (addr.toLowerCase() !== rollupAddressLower) {
-      continue;
-    }
-    const callData = calls[i].callData;
-
-    try {
-      const { functionName: rollupFunctionName } = decodeFunctionData({
-        abi: RollupAbi,
-        data: callData,
-      });
-
-      if (rollupFunctionName === 'propose') {
-        return callData;
-      }
-    } catch {
-      // Skip invalid function data
-      continue;
-    }
-  }
-
-  throw new Error(`Rollup address not found in multicall3 args`);
-}
-
-/**
- * Gets block from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNumber - L2 block number.
- * @returns L2 block from the calldata, deserialized
- */
-async function getBlockFromRollupTx(
-  publicClient: ViemPublicClient,
+export async function getCheckpointBlobDataFromBlobs(
   blobSinkClient: BlobSinkClientInterface,
-  txHash: `0x${string}`,
-  blobHashes: Buffer[], // TODO(md): buffer32?
-  l2BlockNumber: number,
-  rollupAddress: Hex,
-  targetCommitteeSize: number,
+  blockHash: string,
+  blobHashes: Buffer<ArrayBufferLike>[],
+  checkpointNumber: CheckpointNumber,
   logger: Logger,
-): Promise<Omit<RetrievedL2Block, 'l1' | 'chainId' | 'version'>> {
-  const { input: forwarderData, blockHash } = await publicClient.getTransaction({ hash: txHash });
-
-  const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
-  const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
-    abi: RollupAbi,
-    data: rollupData,
-  });
-
-  if (rollupFunctionName !== 'propose') {
-    throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
-  }
-
-  const [decodedArgs, packedAttestations, _signers, _blobInput] = rollupArgs! as readonly [
-    {
-      archive: Hex;
-      stateReference: ViemStateReference;
-      oracleInput: {
-        feeAssetPriceModifier: bigint;
-      };
-      header: ViemHeader;
-      txHashes: readonly Hex[];
-    },
-    ViemCommitteeAttestations,
-    Hex[],
-    Hex,
-  ];
-
-  const attestations = CommitteeAttestation.fromPacked(packedAttestations, targetCommitteeSize);
-
-  logger.trace(`Recovered propose calldata from tx ${txHash}`, {
-    l2BlockNumber,
-    archive: decodedArgs.archive,
-    stateReference: decodedArgs.stateReference,
-    header: decodedArgs.header,
-    blobHashes,
-    attestations,
-    packedAttestations,
-    targetCommitteeSize,
-  });
-
-  // TODO(md): why is the proposed block header different to the actual block header?
-  // This is likely going to be a footgun
-  const header = ProposedBlockHeader.fromViem(decodedArgs.header);
+): Promise<CheckpointBlobData> {
   const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
   if (blobBodies.length === 0) {
-    throw new NoBlobBodiesFoundError(l2BlockNumber);
+    throw new NoBlobBodiesFoundError(checkpointNumber);
   }
 
-  let blockFields: Fr[];
+  let checkpointBlobData: CheckpointBlobData;
   try {
-    blockFields = Blob.toEncodedFields(blobBodies.map(b => b.blob));
+    // Attempt to decode the checkpoint blob data.
+    checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies.map(b => b.blob));
   } catch (err: any) {
     if (err instanceof BlobDeserializationError) {
       logger.fatal(err.message);
     } else {
       logger.fatal('Unable to sync: failed to decode fetched blob, this blob was likely not created by us');
     }
+    // Throwing an error since this is most likely caused by a bug.
     throw err;
   }
 
-  // The blob source gives us blockFields, and we must construct the body from them:
-  const body = Body.fromBlobFields(blockFields);
-
-  const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
-
-  const stateReference = StateReference.fromViem(decodedArgs.stateReference);
-
-  return {
-    l2BlockNumber,
-    archiveRoot,
-    stateReference,
-    header,
-    body,
-    attestations,
-  };
+  return checkpointBlobData;
 }
 
 /** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */
@@ -422,13 +378,13 @@ export async function retrieveL1ToL2Messages(
 
 function mapLogsInboxMessage(logs: GetContractEventsReturnType<typeof InboxAbi, 'MessageSent'>): InboxMessage[] {
   return logs.map(log => {
-    const { index, hash, l2BlockNumber, rollingHash } = log.args;
+    const { index, hash, checkpointNumber, rollingHash } = log.args;
     return {
       index: index!,
       leaf: Fr.fromHexString(hash!),
       l1BlockNumber: log.blockNumber,
       l1BlockHash: Buffer32.fromString(log.blockHash),
-      l2BlockNumber: Number(l2BlockNumber!),
+      checkpointNumber: CheckpointNumber.fromBigInt(checkpointNumber!),
       rollingHash: Buffer16.fromString(rollingHash!),
     };
   });
@@ -440,7 +396,7 @@ export async function retrieveL2ProofVerifiedEvents(
   rollupAddress: EthAddress,
   searchStartBlock: bigint,
   searchEndBlock?: bigint,
-): Promise<{ l1BlockNumber: bigint; l2BlockNumber: number; proverId: Fr; txHash: Hex }[]> {
+): Promise<{ l1BlockNumber: bigint; checkpointNumber: CheckpointNumber; proverId: Fr; txHash: Hex }[]> {
   const logs = await publicClient.getLogs({
     address: rollupAddress.toString(),
     fromBlock: searchStartBlock,
@@ -451,7 +407,7 @@ export async function retrieveL2ProofVerifiedEvents(
 
   return logs.map(log => ({
     l1BlockNumber: log.blockNumber,
-    l2BlockNumber: Number(log.args.blockNumber),
+    checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber),
     proverId: Fr.fromHexString(log.args.proverId),
     txHash: log.transactionHash,
   }));
@@ -463,14 +419,14 @@ export async function retrieveL2ProofsFromRollup(
   rollupAddress: EthAddress,
   searchStartBlock: bigint,
   searchEndBlock?: bigint,
-): Promise<DataRetrieval<{ proof: Proof; proverId: Fr; l2BlockNumber: number; txHash: `0x${string}` }>> {
+): Promise<DataRetrieval<{ proof: Proof; proverId: Fr; checkpointNumber: number; txHash: `0x${string}` }>> {
   const logs = await retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock);
-  const retrievedData: { proof: Proof; proverId: Fr; l2BlockNumber: number; txHash: `0x${string}` }[] = [];
+  const retrievedData: { proof: Proof; proverId: Fr; checkpointNumber: number; txHash: `0x${string}` }[] = [];
   const lastProcessedL1BlockNumber = logs.length > 0 ? logs.at(-1)!.l1BlockNumber : searchStartBlock - 1n;
 
-  for (const { txHash, proverId, l2BlockNumber } of logs) {
+  for (const { txHash, proverId, checkpointNumber } of logs) {
     const proofData = await getProofFromSubmitProofTx(publicClient, txHash, proverId);
-    retrievedData.push({ proof: proofData.proof, proverId: proofData.proverId, l2BlockNumber, txHash });
+    retrievedData.push({ proof: proofData.proof, proverId: proofData.proverId, checkpointNumber, txHash });
   }
   return {
     retrievedData,
@@ -478,26 +434,26 @@ export async function retrieveL2ProofsFromRollup(
   };
 }
 
-export type SubmitBlockProof = {
+export type SubmitEpochProof = {
   archiveRoot: Fr;
   proverId: Fr;
   proof: Proof;
 };
 
 /**
- * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
+ * Gets epoch proof metadata (archive root and proof) from the calldata of an L1 transaction.
  * Assumes that the block was published from an EOA.
  * TODO: Add retries and error management.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block metadata (header and archive) from the calldata, deserialized
+ * @param expectedProverId - Expected prover ID.
+ * @returns Epoch proof metadata from the calldata, deserialized.
  */
 export async function getProofFromSubmitProofTx(
   publicClient: ViemPublicClient,
   txHash: `0x${string}`,
   expectedProverId: Fr,
-): Promise<SubmitBlockProof> {
+): Promise<SubmitEpochProof> {
   const { input: data } = await publicClient.getTransaction({ hash: txHash });
   const { functionName, args } = decodeFunctionData({ abi: RollupAbi, data });