@aztec/archiver 3.0.0-nightly.20251127 → 3.0.0-nightly.20251201.2

package/src/archiver/archiver_store_test_suite.ts

@@ -4,6 +4,7 @@ import {
   PRIVATE_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomInt } from '@aztec/foundation/crypto';
@@ -1189,7 +1190,7 @@ export function describeArchiverDataStore(
           valid: false,
           block: randomBlockInfo(1),
           committee: [EthAddress.random(), EthAddress.random()],
-          epoch: 123n,
+          epoch: EpochNumber(123),
           seed: 456n,
           attestors: [EthAddress.random()],
           attestations: [CommitteeAttestation.random()],
@@ -1208,7 +1209,7 @@ export function describeArchiverDataStore(
           block: randomBlockInfo(2),
           committee: [EthAddress.random()],
           attestors: [EthAddress.random()],
-          epoch: 789n,
+          epoch: EpochNumber(789),
           seed: 101n,
           attestations: [CommitteeAttestation.random()],
           reason: 'invalid-attestation',
@@ -1227,7 +1228,7 @@ export function describeArchiverDataStore(
           valid: false,
           block: randomBlockInfo(3),
           committee: [EthAddress.random()],
-          epoch: 999n,
+          epoch: EpochNumber(999),
           seed: 888n,
           attestors: [EthAddress.random()],
           attestations: [CommitteeAttestation.random()],
@@ -1246,7 +1247,7 @@ export function describeArchiverDataStore(
           valid: false,
           block: randomBlockInfo(4),
           committee: [],
-          epoch: 0n,
+          epoch: EpochNumber(0),
           seed: 0n,
           attestors: [],
           attestations: [],

package/src/archiver/data_retrieval.ts

@@ -12,7 +12,6 @@ import type {
   ViemCommitteeAttestations,
   ViemHeader,
   ViemPublicClient,
-  ViemStateReference,
 } from '@aztec/ethereum';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
@@ -21,7 +20,8 @@ import type { ViemSignature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2Block, L2BlockHeader, PublishedL2Block } 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';
@@ -42,9 +42,9 @@ import type { DataRetrieval } from './structs/data_retrieval.js';
 import type { InboxMessage } from './structs/inbox_message.js';
 import type { L1PublishedData } from './structs/published.js';
 
-export type RetrievedL2Block = {
+export type RetrievedCheckpoint = {
+  checkpointNumber: number;
   archiveRoot: Fr;
-  stateReference: StateReference;
   header: CheckpointHeader;
   checkpointBlobData: CheckpointBlobData;
   l1: L1PublishedData;
@@ -53,16 +53,16 @@ export type RetrievedL2Block = {
   attestations: CommitteeAttestation[];
 };
 
-export async function retrievedBlockToPublishedL2Block({
+export async function retrievedToPublishedCheckpoint({
+  checkpointNumber,
   archiveRoot,
-  stateReference,
   header: checkpointHeader,
   checkpointBlobData,
   l1,
   chainId,
   version,
   attestations,
-}: RetrievedL2Block): Promise<PublishedL2Block> {
+}: RetrievedCheckpoint): Promise<PublishedCheckpoint> {
   const { blocks: blocksBlobData } = checkpointBlobData;
 
   // The lastArchiveRoot of a block is the new archive for the previous block.
@@ -76,7 +76,7 @@ export async function retrievedBlockToPublishedL2Block({
   const l1toL2MessageTreeRoot = blocksBlobData[0].l1ToL2MessageRoot!;
 
   const spongeBlob = SpongeBlob.init();
-  const l2Blocks: L2Block[] = [];
+  const l2Blocks: L2BlockNew[] = [];
   for (let i = 0; i < blocksBlobData.length; i++) {
     const blockBlobData = blocksBlobData[i];
     const { blockEndMarker, blockEndStateField, lastArchiveRoot, noteHashRoot, nullifierRoot, publicDataRoot } =
@@ -115,7 +115,7 @@ export async function retrievedBlockToPublishedL2Block({
     const clonedSpongeBlob = spongeBlob.clone();
     const spongeBlobHash = await clonedSpongeBlob.squeeze();
 
-    const blockHeader = BlockHeader.from({
+    const header = BlockHeader.from({
       lastArchive: new AppendOnlyTreeSnapshot(lastArchiveRoot, l2BlockNumber),
       state,
       spongeBlobHash,
@@ -124,31 +124,24 @@ export async function retrievedBlockToPublishedL2Block({
       totalManaUsed: new Fr(blockEndStateField.totalManaUsed),
     });
 
-    const header = L2BlockHeader.from({
-      ...blockHeader,
-      blockHeadersHash: checkpointHeader.blockHeadersHash,
-      contentCommitment: checkpointHeader.contentCommitment,
-    });
-
     const newArchive = new AppendOnlyTreeSnapshot(newArchiveRoots[i], l2BlockNumber + 1);
 
-    l2Blocks.push(new L2Block(newArchive, header, body));
+    l2Blocks.push(new L2BlockNew(newArchive, header, body));
   }
 
-  const lastBlock = l2Blocks[l2Blocks.length - 1];
-  if (!lastBlock.header.state.equals(stateReference)) {
-    throw new Error(
-      'The claimed state reference submitted to L1 does not match the state reference of the last block.',
-    );
-  }
+  const lastBlock = l2Blocks.at(-1)!;
+  const checkpoint = Checkpoint.from({
+    archive: new AppendOnlyTreeSnapshot(archiveRoot, lastBlock.number + 1),
+    header: checkpointHeader,
+    blocks: l2Blocks,
+    number: checkpointNumber,
+  });
 
-  // TODO(#17027)
-  // There's only one block per checkpoint at the moment.
-  return PublishedL2Block.fromFields({ block: l2Blocks[0], 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 rollupAddress - The address of the rollup contract.
  * @param searchStartBlock - The block number to use for starting the search.
@@ -156,15 +149,15 @@ export async function retrievedBlockToPublishedL2Block({
  * @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,
   blobSinkClient: BlobSinkClientInterface,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
   logger: Logger = createLogger('archiver'),
-): Promise<RetrievedL2Block[]> {
-  const retrievedBlocks: RetrievedL2Block[] = [];
+): Promise<RetrievedCheckpoint[]> {
+  const retrievedCheckpoints: RetrievedCheckpoint[] = [];
 
   let rollupConstants: { chainId: Fr; version: Fr; targetCommitteeSize: number } | undefined;
 
@@ -172,7 +165,7 @@ export async function retrieveBlocksFromRollup(
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const l2BlockProposedLogs = (
+    const checkpointProposedLogs = (
       await rollup.getEvents.CheckpointProposed(
         {},
         {
@@ -182,13 +175,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.checkpointNumber}-${lastLog.args.checkpointNumber} 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) {
@@ -204,52 +197,52 @@ export async function retrieveBlocksFromRollup(
       };
     }
 
-    const newBlocks = await processL2BlockProposedLogs(
+    const newCheckpoints = await processCheckpointProposedLogs(
       rollup,
       publicClient,
       blobSinkClient,
-      l2BlockProposedLogs,
+      checkpointProposedLogs,
       rollupConstants,
       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 logs - CheckpointProposed logs.
+ * @returns - An array of checkpoints.
  */
-async function processL2BlockProposedLogs(
+async function processCheckpointProposedLogs(
   rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
   publicClient: ViemPublicClient,
   blobSinkClient: BlobSinkClientInterface,
   logs: GetContractEventsReturnType<typeof RollupAbi, 'CheckpointProposed'>,
   { chainId, version, targetCommitteeSize }: { chainId: Fr; version: Fr; targetCommitteeSize: number },
   logger: Logger,
-): Promise<RetrievedL2Block[]> {
-  const retrievedBlocks: RetrievedL2Block[] = [];
+): Promise<RetrievedCheckpoint[]> {
+  const retrievedCheckpoints: RetrievedCheckpoint[] = [];
   await asyncPool(10, logs, async log => {
-    const l2BlockNumber = Number(log.args.checkpointNumber!);
+    const checkpointNumber = Number(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(
+      const checkpoint = await getCheckpointFromRollupTx(
         publicClient,
         blobSinkClient,
         log.transactionHash!,
         blobHashes,
-        l2BlockNumber,
+        checkpointNumber,
         rollup.address,
         targetCommitteeSize,
         logger,
@@ -261,22 +254,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, 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> {
@@ -335,25 +328,25 @@ function extractRollupProposeCalldata(multicall3Data: Hex, rollupAddress: Hex):
 }
 
 /**
- * Gets block from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
+ * Gets checkpoint from the calldata of an L1 transaction.
+ * Assumes that the checkpoint 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
+ * @param checkpointNumber - Checkpoint number.
+ * @returns Checkpoint from the calldata, deserialized
  */
-async function getBlockFromRollupTx(
+async function getCheckpointFromRollupTx(
   publicClient: ViemPublicClient,
   blobSinkClient: BlobSinkClientInterface,
   txHash: `0x${string}`,
   blobHashes: Buffer[], // TODO(md): buffer32?
-  l2BlockNumber: number,
+  checkpointNumber: number,
   rollupAddress: Hex,
   targetCommitteeSize: number,
   logger: Logger,
-): Promise<Omit<RetrievedL2Block, 'l1' | 'chainId' | 'version'>> {
-  logger.trace(`Fetching L2 block ${l2BlockNumber} from rollup tx ${txHash}`);
+): Promise<Omit<RetrievedCheckpoint, 'l1' | 'chainId' | 'version'>> {
+  logger.trace(`Fetching checkpoint ${checkpointNumber} from rollup tx ${txHash}`);
   const { input: forwarderData, blockHash } = await publicClient.getTransaction({ hash: txHash });
 
   const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
@@ -369,7 +362,6 @@ async function getBlockFromRollupTx(
   const [decodedArgs, packedAttestations, _signers, _blobInput] = rollupArgs! as readonly [
     {
       archive: Hex;
-      stateReference: ViemStateReference;
       oracleInput: {
         feeAssetPriceModifier: bigint;
       };
@@ -385,9 +377,8 @@ async function getBlockFromRollupTx(
   const attestations = CommitteeAttestation.fromPacked(packedAttestations, targetCommitteeSize);
 
   logger.trace(`Recovered propose calldata from tx ${txHash}`, {
-    l2BlockNumber,
+    checkpointNumber,
     archive: decodedArgs.archive,
-    stateReference: decodedArgs.stateReference,
     header: decodedArgs.header,
     l1BlockHash: blockHash,
     blobHashes,
@@ -399,7 +390,7 @@ async function getBlockFromRollupTx(
   const header = CheckpointHeader.fromViem(decodedArgs.header);
   const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
   if (blobBodies.length === 0) {
-    throw new NoBlobBodiesFoundError(l2BlockNumber);
+    throw new NoBlobBodiesFoundError(checkpointNumber);
   }
 
   let checkpointBlobData: CheckpointBlobData;
@@ -417,11 +408,9 @@ async function getBlockFromRollupTx(
 
   const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
 
-  const stateReference = StateReference.fromViem(decodedArgs.stateReference);
-
   return {
+    checkpointNumber,
     archiveRoot,
-    stateReference,
     header,
     checkpointBlobData,
     attestations,
@@ -492,7 +481,7 @@ export async function retrieveL2ProofVerifiedEvents(
   rollupAddress: EthAddress,
   searchStartBlock: bigint,
   searchEndBlock?: bigint,
-): Promise<{ l1BlockNumber: bigint; l2BlockNumber: number; proverId: Fr; txHash: Hex }[]> {
+): Promise<{ l1BlockNumber: bigint; checkpointNumber: number; proverId: Fr; txHash: Hex }[]> {
   const logs = await publicClient.getLogs({
     address: rollupAddress.toString(),
     fromBlock: searchStartBlock,
@@ -503,7 +492,7 @@ export async function retrieveL2ProofVerifiedEvents(
 
   return logs.map(log => ({
     l1BlockNumber: log.blockNumber,
-    l2BlockNumber: Number(log.args.checkpointNumber),
+    checkpointNumber: Number(log.args.checkpointNumber),
     proverId: Fr.fromHexString(log.args.proverId),
     txHash: log.transactionHash,
   }));
@@ -515,14 +504,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,
@@ -530,26 +519,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 });
 

package/src/archiver/instrumentation.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import {
   Attributes,
   type Gauge,
@@ -139,7 +139,7 @@ export class ArchiverInstrumentation {
     return this.telemetry.isEnabled();
   }
 
-  public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
+  public processNewBlocks(syncTimePerBlock: number, blocks: L2BlockNew[]) {
     this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
     this.syncBlockCount.add(blocks.length);

package/src/archiver/structs/published.ts

@@ -1 +1,2 @@
-export type { PublishedL2Block, L1PublishedData } from '@aztec/stdlib/block';
+export type { PublishedL2Block } from '@aztec/stdlib/block';
+export type { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';

package/src/archiver/validation.ts

@@ -1,45 +1,63 @@
 import type { EpochCache } from '@aztec/epoch-cache';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import type { Logger } from '@aztec/foundation/log';
 import {
-  type PublishedL2Block,
+  type AttestationInfo,
   type ValidateBlockNegativeResult,
   type ValidateBlockResult,
-  getAttestationInfoFromPublishedL2Block,
+  getAttestationInfoFromPayload,
 } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusPayload } from '@aztec/stdlib/p2p';
 
 export type { ValidateBlockResult };
 
 /**
- * Validates the attestations submitted for the given block.
+ * Extracts attestation information from a published checkpoint.
+ * Returns info for each attestation, preserving array indices.
+ */
+export function getAttestationInfoFromPublishedCheckpoint({
+  checkpoint,
+  attestations,
+}: PublishedCheckpoint): AttestationInfo[] {
+  const payload = ConsensusPayload.fromCheckpoint(checkpoint);
+  return getAttestationInfoFromPayload(payload, attestations);
+}
+
+/**
+ * Validates the attestations submitted for the given checkpoint.
  * Returns true if the attestations are valid and sufficient, false otherwise.
  */
-export async function validateBlockAttestations(
-  publishedBlock: PublishedL2Block,
+export async function validateCheckpointAttestations(
+  publishedCheckpoint: PublishedCheckpoint,
   epochCache: EpochCache,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
   logger?: Logger,
 ): Promise<ValidateBlockResult> {
-  const attestorInfos = getAttestationInfoFromPublishedL2Block(publishedBlock);
+  const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint);
   const attestors = compactArray(attestorInfos.map(info => ('address' in info ? info.address : undefined)));
-  const { block } = publishedBlock;
-  const blockHash = await block.hash().then(hash => hash.toString());
-  const archiveRoot = block.archive.root.toString();
-  const slot = block.header.getSlot();
-  const epoch = getEpochAtSlot(slot, constants);
+  const { checkpoint, attestations } = publishedCheckpoint;
+  const headerHash = checkpoint.header.hash();
+  const archiveRoot = checkpoint.archive.root.toString();
+  const slot = checkpoint.header.slotNumber;
+  const epoch: EpochNumber = getEpochAtSlot(slot, constants);
   const { committee, seed } = await epochCache.getCommitteeForEpoch(epoch);
-  const logData = { blockNumber: block.number, slot, epoch, blockHash, archiveRoot };
+  const logData = { checkpointNumber: checkpoint.number, slot, epoch, headerHash, archiveRoot };
 
-  logger?.debug(`Validating attestations for block ${block.number} at slot ${slot} in epoch ${epoch}`, {
+  logger?.debug(`Validating attestations for checkpoint ${checkpoint.number} at slot ${slot} in epoch ${epoch}`, {
     committee: (committee ?? []).map(member => member.toString()),
     recoveredAttestors: attestorInfos,
-    postedAttestations: publishedBlock.attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
+    postedAttestations: attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
     ...logData,
   });
 
   if (!committee || committee.length === 0) {
-    logger?.warn(`No committee found for epoch ${epoch} at slot ${slot}. Accepting block without validation.`, logData);
+    logger?.warn(
+      `No committee found for epoch ${epoch} at slot ${slot}. Accepting checkpoint without validation.`,
+      logData,
+    );
     return { valid: true };
   }
 
@@ -48,12 +66,12 @@ export async function validateBlockAttestations(
   const failedValidationResult = <TReason extends ValidateBlockNegativeResult['reason']>(reason: TReason) => ({
     valid: false as const,
     reason,
-    block: publishedBlock.block.toBlockInfo(),
+    block: checkpoint.blocks[0].toBlockInfo(),
     committee,
     seed,
     epoch,
     attestors,
-    attestations: publishedBlock.attestations,
+    attestations,
   });
 
   for (let i = 0; i < attestorInfos.length; i++) {
@@ -90,7 +108,7 @@ export async function validateBlockAttestations(
 
   const validAttestationCount = attestorInfos.filter(info => info.status === 'recovered-from-signature').length;
   if (validAttestationCount < requiredAttestationCount) {
-    logger?.warn(`Insufficient attestations for block at slot ${slot}`, {
+    logger?.warn(`Insufficient attestations for checkpoint at slot ${slot}`, {
       requiredAttestations: requiredAttestationCount,
       actualAttestations: validAttestationCount,
       ...logData,
@@ -98,6 +116,9 @@ export async function validateBlockAttestations(
     return failedValidationResult('insufficient-attestations');
   }
 
-  logger?.debug(`Block attestations validated successfully for block ${block.number} at slot ${slot}`, logData);
+  logger?.debug(
+    `Checkpoint attestations validated successfully for checkpoint ${checkpoint.number} at slot ${slot}`,
+    logData,
+  );
   return { valid: true };
 }

package/src/index.ts

@@ -2,4 +2,4 @@ export * from './archiver/index.js';
 export * from './factory.js';
 export * from './rpc/index.js';
 
-export { retrieveBlocksFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';
+export { retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';

package/src/test/mock_l2_block_source.ts

@@ -1,5 +1,6 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -182,17 +183,17 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
   }
 
-  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
-      const slot = b.header.globalVariables.slotNumber.toBigInt();
+      const slot = b.header.globalVariables.slotNumber;
       return slot >= start && slot <= end;
     });
     return Promise.resolve(blocks);
   }
 
-  async getBlockHeadersForEpoch(epochNumber: bigint): Promise<BlockHeader[]> {
+  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
     const blocks = await this.getBlocksForEpoch(epochNumber);
     return blocks.map(b => b.getBlockHeader());
   }
@@ -268,15 +269,15 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     };
   }
 
-  getL2EpochNumber(): Promise<bigint> {
+  getL2EpochNumber(): Promise<EpochNumber> {
     throw new Error('Method not implemented.');
   }
 
-  getL2SlotNumber(): Promise<bigint> {
+  getL2SlotNumber(): Promise<SlotNumber> {
     throw new Error('Method not implemented.');
   }
 
-  isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+  isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
     throw new Error('Method not implemented.');
   }