@aztec/slasher 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/tally_slasher_client.ts

@@ -1,10 +1,10 @@
-import { EthAddress } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import type { EpochCache } from '@aztec/epoch-cache';
 import { RollupContract, SlasherContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
 import { maxBigint } from '@aztec/foundation/bigint';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { compactArray, partition, times } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
-import { sleep } from '@aztec/foundation/sleep';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { Prettify } from '@aztec/foundation/types';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
@@ -137,8 +137,6 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     this.roundMonitor.stop();
     await this.offensesCollector.stop();
 
-    // Sleeping to sidestep viem issue with unwatching events
-    await sleep(2000);
     this.log.info('Tally Slasher client stopped');
   }
 
@@ -169,7 +167,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
    * @param slotNumber - The current slot number
    * @returns The actions to take
    */
-  public async getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  public async getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     const [executeAction, voteAction] = await Promise.all([
       this.getExecuteSlashAction(slotNumber),
       this.getVoteOffensesAction(slotNumber),
@@ -182,7 +180,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
    * Returns an execute slash action if there are any rounds ready to be executed.
    * Returns the oldest slash action if there are multiple rounds pending execution.
    */
-  protected async getExecuteSlashAction(slotNumber: bigint): Promise<ProposerSlashAction | undefined> {
+  protected async getExecuteSlashAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined> {
     const { round: currentRound } = this.roundMonitor.getRoundForSlot(slotNumber);
     const slashingExecutionDelayInRounds = BigInt(this.settings.slashingExecutionDelayInRounds);
     const executableRound = currentRound - slashingExecutionDelayInRounds - 1n;
@@ -216,7 +214,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
     // Iterate over all rounds, starting from the oldest, until we find one that is executable
     for (let roundToCheck = oldestExecutableRound; roundToCheck <= executableRound; roundToCheck++) {
-      const action = await this.tryGetRoundExecuteAction(roundToCheck);
+      const action = await this.tryGetRoundExecuteAction(roundToCheck, slotNumber);
       if (action) {
         return action;
       }
@@ -231,17 +229,14 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
    * Assumes round number has already been checked against lifetime and execution delay.
    * @param executableRound - The round to check for execution
    */
-  private async tryGetRoundExecuteAction(executableRound: bigint): Promise<ProposerSlashAction | undefined> {
-    let logData: Record<string, unknown> = { executableRound };
+  private async tryGetRoundExecuteAction(
+    executableRound: bigint,
+    slotNumber: SlotNumber,
+  ): Promise<ProposerSlashAction | undefined> {
+    let logData: Record<string, unknown> = { executableRound, slotNumber };
     this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
 
     try {
-      // Check if slashing is enabled at all
-      if (!(await this.slasher.isSlashingEnabled())) {
-        this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`, logData);
-        return undefined;
-      }
-
       const roundInfo = await this.tallySlashingProposer.getRound(executableRound);
       logData = { ...logData, roundInfo };
       if (roundInfo.isExecuted) {
@@ -255,6 +250,16 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
         return undefined;
       }
 
+      // Check if round is ready to execute at the given slot
+      const isReadyToExecute = await this.tallySlashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
+      if (!isReadyToExecute) {
+        this.log.warn(
+          `Round ${executableRound} is not ready to execute at slot ${slotNumber} according to contract check`,
+          logData,
+        );
+        return undefined;
+      }
+
       // Check if the round yields any slashing at all
       const { actions: slashActions, committees } = await this.tallySlashingProposer.getTally(executableRound);
       if (slashActions.length === 0) {
@@ -273,8 +278,12 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
         return undefined;
       }
 
+      const slashActionsWithAmounts = slashActions.map(action => ({
+        validator: action.validator.toString(),
+        slashAmount: action.slashAmount.toString(),
+      }));
       this.log.info(`Round ${executableRound} is ready to execute with ${slashActions.length} slashes`, {
-        slashActions,
+        slashActions: slashActionsWithAmounts,
         payloadAddress: payload.address.toString(),
         ...logData,
       });
@@ -295,7 +304,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
   }
 
   /** Returns a vote action based on offenses from the target round (with offset applied) */
-  protected async getVoteOffensesAction(slotNumber: bigint): Promise<ProposerSlashAction | undefined> {
+  protected async getVoteOffensesAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined> {
     // Compute what round we are in based on the slot number and what round will be slashed
     const { round: currentRound } = this.roundMonitor.getRoundForSlot(slotNumber);
     const slashedRound = this.getSlashedRound(currentRound);
@@ -340,16 +349,25 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       return undefined;
     }
 
+    const offensesToSlashLog = offensesToSlash.map(offense => ({
+      ...offense,
+      amount: offense.amount.toString(),
+    }));
     this.log.info(`Voting to slash ${offensesToSlash.length} offenses`, {
       slotNumber,
       currentRound,
       slashedRound,
-      offensesToSlash,
+      offensesToSlash: offensesToSlashLog,
     });
 
     const committees = await this.collectCommitteesActiveDuringRound(slashedRound);
     const epochsForCommittees = getEpochsForRound(slashedRound, this.settings);
-    const votes = getSlashConsensusVotesFromOffenses(offensesToSlash, committees, epochsForCommittees, this.settings);
+    const votes = getSlashConsensusVotesFromOffenses(
+      offensesToSlash,
+      committees,
+      epochsForCommittees.map(e => BigInt(e)),
+      this.settings,
+    );
     if (votes.every(v => v === 0)) {
       this.log.warn(`Computed votes for offenses are all zero. Skipping vote.`, {
         slotNumber,

package/src/watcher.ts

@@ -10,7 +10,7 @@ export interface WantToSlashArgs {
   validator: EthAddress;
   amount: bigint;
   offenseType: OffenseType;
-  epochOrSlot: bigint; // Epoch number for epoch-based offenses, block number for block-based
+  epochOrSlot: bigint; // Epoch number for epoch-based offenses, slot number for slot-based
 }
 
 // Event map for specific, known events of a watcher

package/src/watchers/attestations_block_watcher.ts

@@ -1,13 +1,14 @@
 import { EpochCache } from '@aztec/epoch-cache';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { merge, pick } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
-  type InvalidBlockDetectedEvent,
-  type L2BlockInfo,
+  type InvalidCheckpointDetectedEvent,
   type L2BlockSourceEventEmitter,
   L2BlockSourceEvents,
-  type ValidateBlockNegativeResult,
+  type ValidateCheckpointNegativeResult,
 } from '@aztec/stdlib/block';
+import type { CheckpointInfo } from '@aztec/stdlib/checkpoint';
 import { OffenseType } from '@aztec/stdlib/slashing';
 
 import EventEmitter from 'node:events';
@@ -31,19 +32,19 @@ type AttestationsBlockWatcherConfig = Pick<SlasherConfig, (typeof AttestationsBl
 export class AttestationsBlockWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
   private log: Logger = createLogger('attestations-block-watcher');
 
-  // Only keep track of the last N invalid blocks
-  private maxInvalidBlocks = 100;
+  // Only keep track of the last N invalid checkpoints
+  private maxInvalidCheckpoints = 100;
 
   // All invalid archive roots seen
   private invalidArchiveRoots: Set<string> = new Set();
 
   private config: AttestationsBlockWatcherConfig;
 
-  private boundHandleInvalidBlock = (event: InvalidBlockDetectedEvent) => {
+  private boundHandleInvalidCheckpoint = (event: InvalidCheckpointDetectedEvent) => {
     try {
-      this.handleInvalidBlock(event);
+      this.handleInvalidCheckpoint(event);
     } catch (err) {
-      this.log.error('Error handling invalid block', err, {
+      this.log.error('Error handling invalid checkpoint', err, {
         ...event.validationResult,
         reason: event.validationResult.reason,
       });
@@ -66,54 +67,61 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
   }
 
   public start() {
-    this.l2BlockSource.on(L2BlockSourceEvents.InvalidAttestationsBlockDetected, this.boundHandleInvalidBlock);
+    this.l2BlockSource.events.on(
+      L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
+      this.boundHandleInvalidCheckpoint,
+    );
     return Promise.resolve();
   }
 
   public stop() {
-    this.l2BlockSource.removeListener(
-      L2BlockSourceEvents.InvalidAttestationsBlockDetected,
-      this.boundHandleInvalidBlock,
+    this.l2BlockSource.events.removeListener(
+      L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
+      this.boundHandleInvalidCheckpoint,
     );
     return Promise.resolve();
   }
 
-  private handleInvalidBlock(event: InvalidBlockDetectedEvent): void {
+  /** Event handler for invalid checkpoints as reported by the archiver. Public for testing purposes. */
+  public handleInvalidCheckpoint(event: InvalidCheckpointDetectedEvent): void {
     const { validationResult } = event;
-    const block = validationResult.block;
+    const checkpoint = validationResult.checkpoint;
 
-    // Check if we already have processed this block, archiver may emit the same event multiple times
-    if (this.invalidArchiveRoots.has(block.archive.toString())) {
-      this.log.trace(`Already processed invalid block ${block.blockNumber}`);
+    // Check if we already have processed this checkpoint, archiver may emit the same event multiple times
+    if (this.invalidArchiveRoots.has(checkpoint.archive.toString())) {
+      this.log.trace(`Already processed invalid checkpoint ${checkpoint.checkpointNumber}`);
       return;
     }
 
-    this.log.verbose(`Detected invalid block ${block.blockNumber}`, {
-      ...block,
+    this.log.verbose(`Detected invalid checkpoint ${checkpoint.checkpointNumber}`, {
+      ...checkpoint,
       reason: validationResult.valid === false ? validationResult.reason : 'unknown',
     });
 
-    // Store the invalid block
-    this.addInvalidBlock(event.validationResult.block);
+    // Store the invalid checkpoint
+    this.addInvalidCheckpoint(event.validationResult.checkpoint);
 
-    // Slash the proposer of the invalid block
+    // Slash the proposer of the invalid checkpoint
     this.slashProposer(event.validationResult);
 
-    // Check if the parent of this block is invalid as well, if so, we will slash its attestors as well
+    // Check if the parent of this checkpoint is invalid as well, if so, we will slash its attestors as well
     this.slashAttestorsOnAncestorInvalid(event.validationResult);
   }
 
-  private slashAttestorsOnAncestorInvalid(validationResult: ValidateBlockNegativeResult) {
-    const block = validationResult.block;
+  private slashAttestorsOnAncestorInvalid(validationResult: ValidateCheckpointNegativeResult) {
+    const checkpoint = validationResult.checkpoint;
 
-    const parentArchive = block.lastArchive.toString();
+    const parentArchive = checkpoint.lastArchive.toString();
     if (this.invalidArchiveRoots.has(parentArchive)) {
       const attestors = validationResult.attestors;
-      this.log.info(`Want to slash attestors of block ${block.blockNumber} built on invalid block`, {
-        ...block,
-        ...attestors,
-        parentArchive,
-      });
+      this.log.info(
+        `Want to slash attestors of checkpoint ${checkpoint.checkpointNumber} built on invalid checkpoint`,
+        {
+          ...checkpoint,
+          ...attestors,
+          parentArchive,
+        },
+      );
 
       this.emit(
         WANT_TO_SLASH_EVENT,
@@ -121,20 +129,26 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
           validator: attestor,
           amount: this.config.slashAttestDescendantOfInvalidPenalty,
           offenseType: OffenseType.ATTESTED_DESCENDANT_OF_INVALID,
-          epochOrSlot: BigInt(block.slotNumber),
+          epochOrSlot: BigInt(SlotNumber(checkpoint.slotNumber)),
         })),
       );
     }
   }
 
-  private slashProposer(validationResult: ValidateBlockNegativeResult) {
-    const { reason, block } = validationResult;
-    const blockNumber = block.blockNumber;
-    const slot = BigInt(block.slotNumber);
-    const proposer = this.epochCache.getProposerFromEpochCommittee(validationResult, slot);
+  private slashProposer(validationResult: ValidateCheckpointNegativeResult) {
+    const { reason, checkpoint } = validationResult;
+    const checkpointNumber = checkpoint.checkpointNumber;
+    const slot = checkpoint.slotNumber;
+    const epochCommitteeInfo = {
+      committee: validationResult.committee,
+      seed: validationResult.seed,
+      epoch: validationResult.epoch,
+      isEscapeHatchOpen: false,
+    };
+    const proposer = this.epochCache.getProposerFromEpochCommittee(epochCommitteeInfo, slot);
 
     if (!proposer) {
-      this.log.warn(`No proposer found for block ${blockNumber} at slot ${slot}`);
+      this.log.warn(`No proposer found for checkpoint ${checkpointNumber} at slot ${slot}`);
       return;
     }
 
@@ -144,18 +158,18 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
       validator: proposer,
       amount,
       offenseType: offense,
-      epochOrSlot: slot,
+      epochOrSlot: BigInt(slot),
     };
 
-    this.log.info(`Want to slash proposer of block ${blockNumber} due to ${reason}`, {
-      ...block,
+    this.log.info(`Want to slash proposer of checkpoint ${checkpointNumber} due to ${reason}`, {
+      ...checkpoint,
       ...args,
     });
 
     this.emit(WANT_TO_SLASH_EVENT, [args]);
   }
 
-  private getOffenseFromInvalidationReason(reason: ValidateBlockNegativeResult['reason']): OffenseType {
+  private getOffenseFromInvalidationReason(reason: ValidateCheckpointNegativeResult['reason']): OffenseType {
     switch (reason) {
       case 'invalid-attestation':
         return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
@@ -168,11 +182,11 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
     }
   }
 
-  private addInvalidBlock(block: L2BlockInfo) {
-    this.invalidArchiveRoots.add(block.archive.toString());
+  private addInvalidCheckpoint(checkpoint: CheckpointInfo) {
+    this.invalidArchiveRoots.add(checkpoint.archive.toString());
 
     // Prune old entries if we exceed the maximum
-    if (this.invalidArchiveRoots.size > this.maxInvalidBlocks) {
+    if (this.invalidArchiveRoots.size > this.maxInvalidCheckpoints) {
       const oldestKey = this.invalidArchiveRoots.keys().next().value!;
       this.invalidArchiveRoots.delete(oldestKey);
     }

package/src/watchers/epoch_prune_watcher.ts

@@ -1,22 +1,26 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import { merge, pick } from '@aztec/foundation/collection';
+import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { chunkBy, merge, pick } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
   EthAddress,
   L2Block,
-  type L2BlockPruneEvent,
   type L2BlockSourceEventEmitter,
   L2BlockSourceEvents,
+  type L2PruneUnprovenEvent,
 } from '@aztec/stdlib/block';
 import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import type {
-  IFullNodeBlockBuilder,
+  ICheckpointBlockBuilder,
+  ICheckpointsBuilder,
   ITxProvider,
   MerkleTreeWriteOperations,
   SlasherConfig,
 } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { type L1ToL2MessageSource, computeCheckpointOutHash } from '@aztec/stdlib/messaging';
 import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
+import type { CheckpointGlobalVariables } from '@aztec/stdlib/tx';
 import {
   ReExFailedTxsError,
   ReExStateMismatchError,
@@ -51,7 +55,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private epochCache: EpochCache,
     private txProvider: Pick<ITxProvider, 'getAvailableTxs'>,
-    private blockBuilder: IFullNodeBlockBuilder,
+    private checkpointsBuilder: ICheckpointsBuilder,
     penalties: EpochPruneWatcherPenalties,
   ) {
     super();
@@ -62,12 +66,12 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   }
 
   public start() {
-    this.l2BlockSource.on(L2BlockSourceEvents.L2PruneDetected, this.boundHandlePruneL2Blocks);
+    this.l2BlockSource.events.on(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
     return Promise.resolve();
   }
 
   public stop() {
-    this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.boundHandlePruneL2Blocks);
+    this.l2BlockSource.events.removeListener(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
     return Promise.resolve();
   }
 
@@ -76,34 +80,34 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     this.log.verbose('EpochPruneWatcher config updated', this.penalties);
   }
 
-  private handlePruneL2Blocks(event: L2BlockPruneEvent): void {
+  private handlePruneL2Blocks(event: L2PruneUnprovenEvent): void {
     const { blocks, epochNumber } = event;
     void this.processPruneL2Blocks(blocks, epochNumber).catch(err =>
       this.log.error('Error processing pruned L2 blocks', err, { epochNumber }),
     );
   }
 
-  private async emitSlashForEpoch(offense: OffenseType, epochNumber: bigint): Promise<void> {
+  private async emitSlashForEpoch(offense: OffenseType, epochNumber: EpochNumber): Promise<void> {
     const validators = await this.getValidatorsForEpoch(epochNumber);
     if (validators.length === 0) {
       this.log.warn(`No validators found for epoch ${epochNumber} (cannot slash for ${getOffenseTypeName(offense)})`);
       return;
     }
-    const args = this.validatorsToSlashingArgs(validators, offense, BigInt(epochNumber));
+    const args = this.validatorsToSlashingArgs(validators, offense, epochNumber);
     this.log.verbose(`Created slash for ${getOffenseTypeName(offense)} at epoch ${epochNumber}`, args);
     this.emit(WANT_TO_SLASH_EVENT, args);
   }
 
-  private async processPruneL2Blocks(blocks: L2Block[], epochNumber: bigint): Promise<void> {
+  private async processPruneL2Blocks(blocks: L2Block[], epochNumber: EpochNumber): Promise<void> {
     try {
       const l1Constants = this.epochCache.getL1Constants();
-      const epochBlocks = blocks.filter(b => getEpochAtSlot(b.slot, l1Constants) === epochNumber);
+      const epochBlocks = blocks.filter(b => getEpochAtSlot(b.header.getSlot(), l1Constants) === epochNumber);
       this.log.info(
         `Detected chain prune. Validating epoch ${epochNumber} with blocks ${epochBlocks[0]?.number} to ${epochBlocks[epochBlocks.length - 1]?.number}.`,
         { blocks: epochBlocks.map(b => b.toBlockInfo()) },
       );
 
-      await this.validateBlocks(epochBlocks);
+      await this.validateBlocks(epochBlocks, epochNumber);
       this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
       await this.emitSlashForEpoch(OffenseType.VALID_EPOCH_PRUNED, epochNumber);
     } catch (error) {
@@ -118,21 +122,83 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     }
   }
 
-  public async validateBlocks(blocks: L2Block[]): Promise<void> {
+  public async validateBlocks(blocks: L2Block[], epochNumber: EpochNumber): Promise<void> {
     if (blocks.length === 0) {
       return;
     }
-    const fork = await this.blockBuilder.getFork(blocks[0].header.globalVariables.blockNumber - 1);
+
+    // Sort blocks by block number and group by checkpoint
+    const sortedBlocks = [...blocks].sort((a, b) => a.number - b.number);
+    const blocksByCheckpoint = chunkBy(sortedBlocks, b => b.checkpointNumber);
+
+    // Get prior checkpoints in the epoch (in case this was a partial prune) to extract the out hashes
+    const priorCheckpointOutHashes = (await this.l2BlockSource.getCheckpointsDataForEpoch(epochNumber))
+      .filter(c => c.checkpointNumber < sortedBlocks[0].checkpointNumber)
+      .map(c => c.checkpointOutHash);
+    let previousCheckpointOutHashes: Fr[] = [...priorCheckpointOutHashes];
+
+    const fork = await this.checkpointsBuilder.getFork(
+      BlockNumber(sortedBlocks[0].header.globalVariables.blockNumber - 1),
+    );
     try {
-      for (const block of blocks) {
-        await this.validateBlock(block, fork);
+      for (const checkpointBlocks of blocksByCheckpoint) {
+        await this.validateCheckpoint(checkpointBlocks, previousCheckpointOutHashes, fork);
+
+        // Compute checkpoint out hash from all blocks in this checkpoint
+        const checkpointOutHash = computeCheckpointOutHash(
+          checkpointBlocks.map(b => b.body.txEffects.map(tx => tx.l2ToL1Msgs)),
+        );
+        previousCheckpointOutHashes = [...previousCheckpointOutHashes, checkpointOutHash];
       }
     } finally {
       await fork.close();
     }
   }
 
-  public async validateBlock(blockFromL1: L2Block, fork: MerkleTreeWriteOperations): Promise<void> {
+  private async validateCheckpoint(
+    checkpointBlocks: L2Block[],
+    previousCheckpointOutHashes: Fr[],
+    fork: MerkleTreeWriteOperations,
+  ): Promise<void> {
+    const checkpointNumber = checkpointBlocks[0].checkpointNumber;
+    this.log.debug(`Validating pruned checkpoint ${checkpointNumber} with ${checkpointBlocks.length} blocks`);
+
+    // Get L1ToL2Messages once for the entire checkpoint
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+
+    // Build checkpoint constants from first block's global variables
+    const gv = checkpointBlocks[0].header.globalVariables;
+    const constants: CheckpointGlobalVariables = {
+      chainId: gv.chainId,
+      version: gv.version,
+      slotNumber: gv.slotNumber,
+      timestamp: gv.timestamp,
+      coinbase: gv.coinbase,
+      feeRecipient: gv.feeRecipient,
+      gasFees: gv.gasFees,
+    };
+
+    // Start checkpoint builder once for all blocks in this checkpoint
+    const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(
+      checkpointNumber,
+      constants,
+      0n, // feeAssetPriceModifier is not used for validation of the checkpoint content
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      fork,
+      this.log.getBindings(),
+    );
+
+    // Validate all blocks in the checkpoint sequentially
+    for (const block of checkpointBlocks) {
+      await this.validateBlockInCheckpoint(block, checkpointBuilder);
+    }
+  }
+
+  private async validateBlockInCheckpoint(
+    blockFromL1: L2Block,
+    checkpointBuilder: ICheckpointBlockBuilder,
+  ): Promise<void> {
     this.log.debug(`Validating pruned block ${blockFromL1.header.globalVariables.blockNumber}`);
     const txHashes = blockFromL1.body.txEffects.map(txEffect => txEffect.txHash);
     // We load txs from the mempool directly, since the TxCollector running in the background has already been
@@ -144,14 +210,9 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
       throw new TransactionsNotAvailableError(missingTxs);
     }
 
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockFromL1.number);
-    const { block, failedTxs, numTxs } = await this.blockBuilder.buildBlock(
-      txs,
-      l1ToL2Messages,
-      blockFromL1.header.globalVariables,
-      {},
-      fork,
-    );
+    const gv = blockFromL1.header.globalVariables;
+    const { block, failedTxs, numTxs } = await checkpointBuilder.buildBlock(txs, gv.blockNumber, gv.timestamp, {});
+
     if (numTxs !== txs.length) {
       // This should be detected by state mismatch, but this makes it easier to debug.
       throw new ValidatorError(`Built block with ${numTxs} txs, expected ${txs.length}`);
@@ -164,7 +225,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     }
   }
 
-  private async getValidatorsForEpoch(epochNumber: bigint): Promise<EthAddress[]> {
+  private async getValidatorsForEpoch(epochNumber: EpochNumber): Promise<EthAddress[]> {
     const { committee } = await this.epochCache.getCommitteeForEpoch(epochNumber);
     if (!committee) {
       this.log.trace(`No committee found for epoch ${epochNumber}`);
@@ -176,7 +237,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   private validatorsToSlashingArgs(
     validators: EthAddress[],
     offenseType: OffenseType,
-    epochOrSlot: bigint,
+    epochOrSlot: EpochNumber,
   ): WantToSlashArgs[] {
     const penalty =
       offenseType === OffenseType.DATA_WITHHOLDING
@@ -186,7 +247,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
       validator: v,
       amount: penalty,
       offenseType,
-      epochOrSlot,
+      epochOrSlot: BigInt(epochOrSlot),
     }));
   }
 }