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

package/src/tally_slasher_client.ts

@@ -1,6 +1,8 @@
-import { EthAddress } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+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';
@@ -45,7 +47,7 @@ export type TallySlasherSettings = Prettify<
 >;
 
 export type TallySlasherClientConfig = SlashOffensesCollectorConfig &
-  Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever'>;
+  Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack'>;
 
 /**
  * The Tally Slasher client is responsible for managing slashable offenses using
@@ -88,6 +90,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     private config: TallySlasherClientConfig,
     private settings: TallySlasherSettings,
     private tallySlashingProposer: TallySlashingProposerContract,
+    private slasher: SlasherContract,
     private rollup: RollupContract,
     watchers: Watcher[],
     private epochCache: EpochCache,
@@ -167,7 +170,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),
@@ -176,29 +179,91 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     return compactArray<ProposerSlashAction>([executeAction, voteAction]);
   }
 
-  /** Returns an execute slash action if there are any rounds ready to be executed */
-  protected async getExecuteSlashAction(slotNumber: bigint): Promise<ProposerSlashAction | undefined> {
+  /**
+   * 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: SlotNumber): Promise<ProposerSlashAction | undefined> {
     const { round: currentRound } = this.roundMonitor.getRoundForSlot(slotNumber);
     const slashingExecutionDelayInRounds = BigInt(this.settings.slashingExecutionDelayInRounds);
     const executableRound = currentRound - slashingExecutionDelayInRounds - 1n;
-    if (executableRound < 0n) {
+    const lookBack = BigInt(this.config.slashExecuteRoundsLookBack);
+    const slashingLifetimeInRounds = BigInt(this.settings.slashingLifetimeInRounds);
+
+    // Compute the oldest executable round considering both lookBack and lifetimeInRounds
+    // A round is only executable if currentRound <= round + lifetimeInRounds
+    // So the oldest round we can execute is: currentRound - lifetimeInRounds
+    const oldestByLifetime = maxBigint(0n, currentRound - slashingLifetimeInRounds);
+    const oldestByLookBack = maxBigint(0n, executableRound - lookBack);
+    const oldestExecutableRound = maxBigint(oldestByLifetime, oldestByLookBack);
+
+    // Check if slashing is enabled at all
+    if (!(await this.slasher.isSlashingEnabled())) {
+      this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`);
       return undefined;
     }
 
-    const logData = { currentRound, executableRound, slotNumber };
+    this.log.debug(`Checking slashing rounds ${oldestExecutableRound} to ${executableRound} to execute`, {
+      slotNumber,
+      currentRound,
+      oldestExecutableRound,
+      oldestByLifetime,
+      oldestByLookBack,
+      executableRound,
+      slashingExecutionDelayInRounds,
+      lookBack,
+      slashingLifetimeInRounds,
+    });
+
+    // 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, slotNumber);
+      if (action) {
+        return action;
+      }
+    }
+
+    // And return nothing if none are found
+    return undefined;
+  }
+
+  /**
+   * Checks if a given round is executable and returns an execute-slash action for it if so.
+   * 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,
+    slotNumber: SlotNumber,
+  ): Promise<ProposerSlashAction | undefined> {
+    let logData: Record<string, unknown> = { executableRound, slotNumber };
+    this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
+
     try {
       const roundInfo = await this.tallySlashingProposer.getRound(executableRound);
+      logData = { ...logData, roundInfo };
       if (roundInfo.isExecuted) {
         this.log.verbose(`Round ${executableRound} has already been executed`, logData);
         return undefined;
-      } else if (!roundInfo.readyToExecute) {
-        this.log.verbose(`Round ${executableRound} is not ready to execute yet`, logData);
+      } else if (roundInfo.voteCount === 0n) {
+        this.log.debug(`Round ${executableRound} received no votes`, logData);
         return undefined;
       } else if (roundInfo.voteCount < this.settings.slashingQuorumSize) {
         this.log.verbose(`Round ${executableRound} does not have enough votes to execute`, logData);
         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) {
         this.log.verbose(`Round ${executableRound} does not resolve in any slashing`, logData);
@@ -207,8 +272,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
       // Check if the slash payload is vetoed
       const payload = await this.tallySlashingProposer.getPayload(executableRound);
-      const slasherContract = await this.rollup.getSlasherContract();
-      const isVetoed = await slasherContract.isPayloadVetoed(payload.address);
+      const isVetoed = await this.slasher.isPayloadVetoed(payload.address);
       if (isVetoed) {
         this.log.warn(`Round ${executableRound} payload is vetoed (skipping execution)`, {
           payloadAddress: payload.address.toString(),
@@ -234,13 +298,12 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       return { type: 'execute-slash', round: executableRound, committees: slashedCommittees };
     } catch (error) {
       this.log.error(`Error checking round to execute ${executableRound}`, error);
+      return undefined;
     }
-
-    return undefined;
   }
 
   /** 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);
@@ -294,7 +357,12 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
     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/test/dummy_watcher.ts

@@ -0,0 +1,21 @@
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+
+import EventEmitter from 'node:events';
+
+import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
+
+export class DummyWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
+  public updateConfig(_config: Partial<SlasherConfig>) {}
+
+  public start() {
+    return Promise.resolve();
+  }
+
+  public stop() {
+    return Promise.resolve();
+  }
+
+  public triggerSlash(args: WantToSlashArgs[]) {
+    this.emit(WANT_TO_SLASH_EVENT, args);
+  }
+}

package/src/watcher.ts

@@ -2,13 +2,15 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import { OffenseType } from '@aztec/stdlib/slashing';
 
+import type { SlasherConfig } from './config.js';
+
 export const WANT_TO_SLASH_EVENT = 'want-to-slash' as const;
 
 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
@@ -21,4 +23,5 @@ export type WatcherEmitter = TypedEventEmitter<WatcherEventMap>;
 export type Watcher = WatcherEmitter & {
   start?: () => Promise<void>;
   stop?: () => Promise<void>;
+  updateConfig: (config: Partial<SlasherConfig>) => void;
 };

package/src/watchers/attestations_block_watcher.ts

@@ -1,10 +1,12 @@
 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 L2BlockSourceEventEmitter,
   L2BlockSourceEvents,
-  PublishedL2Block,
   type ValidateBlockNegativeResult,
 } from '@aztec/stdlib/block';
 import { OffenseType } from '@aztec/stdlib/slashing';
@@ -14,6 +16,13 @@ import EventEmitter from 'node:events';
 import type { SlasherConfig } from '../config.js';
 import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
 
+const AttestationsBlockWatcherConfigKeys = [
+  'slashAttestDescendantOfInvalidPenalty',
+  'slashProposeInvalidAttestationsPenalty',
+] as const;
+
+type AttestationsBlockWatcherConfig = Pick<SlasherConfig, (typeof AttestationsBlockWatcherConfigKeys)[number]>;
+
 /**
  * This watcher is responsible for detecting invalid blocks and creating slashing arguments for offenders.
  * An invalid block is one that doesn't have enough attestations or has incorrect attestations.
@@ -29,13 +38,14 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
   // All invalid archive roots seen
   private invalidArchiveRoots: Set<string> = new Set();
 
+  private config: AttestationsBlockWatcherConfig;
+
   private boundHandleInvalidBlock = (event: InvalidBlockDetectedEvent) => {
     try {
       this.handleInvalidBlock(event);
     } catch (err) {
       this.log.error('Error handling invalid block', err, {
-        ...event.validationResult.block.block.toBlockInfo(),
-        ...event.validationResult.block.l1,
+        ...event.validationResult,
         reason: event.validationResult.reason,
       });
     }
@@ -44,13 +54,16 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
   constructor(
     private l2BlockSource: L2BlockSourceEventEmitter,
     private epochCache: EpochCache,
-    private config: Pick<
-      SlasherConfig,
-      'slashAttestDescendantOfInvalidPenalty' | 'slashProposeInvalidAttestationsPenalty'
-    >,
+    config: AttestationsBlockWatcherConfig,
   ) {
     super();
-    this.log.info('InvalidBlockWatcher initialized');
+    this.config = pick(config, ...AttestationsBlockWatcherConfigKeys);
+    this.log.info('AttestationsBlockWatcher initialized');
+  }
+
+  public updateConfig(newConfig: Partial<AttestationsBlockWatcherConfig>) {
+    this.config = merge(this.config, pick(newConfig, ...AttestationsBlockWatcherConfigKeys));
+    this.log.verbose('AttestationsBlockWatcher config updated', this.config);
   }
 
   public start() {
@@ -68,16 +81,16 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
 
   private handleInvalidBlock(event: InvalidBlockDetectedEvent): void {
     const { validationResult } = event;
-    const block = validationResult.block.block;
+    const block = validationResult.block;
 
     // Check if we already have processed this block, archiver may emit the same event multiple times
-    if (this.invalidArchiveRoots.has(block.archive.root.toString())) {
-      this.log.trace(`Already processed invalid block ${block.number}`);
+    if (this.invalidArchiveRoots.has(block.archive.toString())) {
+      this.log.trace(`Already processed invalid block ${block.blockNumber}`);
       return;
     }
 
-    this.log.verbose(`Detected invalid block ${block.number}`, {
-      ...block.toBlockInfo(),
+    this.log.verbose(`Detected invalid block ${block.blockNumber}`, {
+      ...block,
       reason: validationResult.valid === false ? validationResult.reason : 'unknown',
     });
 
@@ -94,11 +107,11 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
   private slashAttestorsOnAncestorInvalid(validationResult: ValidateBlockNegativeResult) {
     const block = validationResult.block;
 
-    const parentArchive = block.block.header.lastArchive.root.toString();
-    if (this.invalidArchiveRoots.has(block.block.header.lastArchive.root.toString())) {
-      const attestors = validationResult.attestations.map(a => a.getSender());
-      this.log.info(`Want to slash attestors of block ${block.block.number} built on invalid block`, {
-        ...block.block.toBlockInfo(),
+    const parentArchive = block.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,
       });
@@ -109,7 +122,7 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
           validator: attestor,
           amount: this.config.slashAttestDescendantOfInvalidPenalty,
           offenseType: OffenseType.ATTESTED_DESCENDANT_OF_INVALID,
-          epochOrSlot: block.block.slot,
+          epochOrSlot: BigInt(SlotNumber(block.slotNumber)),
         })),
       );
     }
@@ -117,8 +130,8 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
 
   private slashProposer(validationResult: ValidateBlockNegativeResult) {
     const { reason, block } = validationResult;
-    const blockNumber = block.block.number;
-    const slot = block.block.header.getSlot();
+    const blockNumber = block.blockNumber;
+    const slot = block.slotNumber;
     const proposer = this.epochCache.getProposerFromEpochCommittee(validationResult, slot);
 
     if (!proposer) {
@@ -132,11 +145,11 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
       validator: proposer,
       amount,
       offenseType: offense,
-      epochOrSlot: block.block.slot,
+      epochOrSlot: BigInt(slot),
     };
 
     this.log.info(`Want to slash proposer of block ${blockNumber} due to ${reason}`, {
-      ...block.block.toBlockInfo(),
+      ...block,
       ...args,
     });
 
@@ -156,8 +169,8 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
     }
   }
 
-  private addInvalidBlock(block: PublishedL2Block) {
-    this.invalidArchiveRoots.add(block.block.archive.root.toString());
+  private addInvalidBlock(block: L2BlockInfo) {
+    this.invalidArchiveRoots.add(block.archive.toString());
 
     // Prune old entries if we exceed the maximum
     if (this.invalidArchiveRoots.size > this.maxInvalidBlocks) {

package/src/watchers/epoch_prune_watcher.ts

@@ -1,5 +1,6 @@
-import type { Tx } from '@aztec/aztec.js';
 import { EpochCache } from '@aztec/epoch-cache';
+import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
   EthAddress,
@@ -8,9 +9,15 @@ import {
   type L2BlockSourceEventEmitter,
   L2BlockSourceEvents,
 } from '@aztec/stdlib/block';
-import type { IFullNodeBlockBuilder, ITxProvider, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import type {
+  IFullNodeBlockBuilder,
+  ITxProvider,
+  MerkleTreeWriteOperations,
+  SlasherConfig,
+} from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import { OffenseType } from '@aztec/stdlib/slashing';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
 import {
   ReExFailedTxsError,
   ReExStateMismatchError,
@@ -22,10 +29,9 @@ import EventEmitter from 'node:events';
 
 import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
 
-type EpochPruneWatcherPenalties = {
-  slashPrunePenalty: bigint;
-  slashDataWithholdingPenalty: bigint;
-};
+const EpochPruneWatcherPenaltiesConfigKeys = ['slashPrunePenalty', 'slashDataWithholdingPenalty'] as const;
+
+type EpochPruneWatcherPenalties = Pick<SlasherConfig, (typeof EpochPruneWatcherPenaltiesConfigKeys)[number]>;
 
 /**
  * This watcher is responsible for detecting chain prunes and creating slashing arguments for the committee.
@@ -39,15 +45,18 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   // Store bound function reference for proper listener removal
   private boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
 
+  private penalties: EpochPruneWatcherPenalties;
+
   constructor(
     private l2BlockSource: L2BlockSourceEventEmitter,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private epochCache: EpochCache,
     private txProvider: Pick<ITxProvider, 'getAvailableTxs'>,
     private blockBuilder: IFullNodeBlockBuilder,
-    private penalties: EpochPruneWatcherPenalties,
+    penalties: EpochPruneWatcherPenalties,
   ) {
     super();
+    this.penalties = pick(penalties, ...EpochPruneWatcherPenaltiesConfigKeys);
     this.log.verbose(
       `EpochPruneWatcher initialized with penalties: valid epoch pruned=${penalties.slashPrunePenalty} data withholding=${penalties.slashDataWithholdingPenalty}`,
     );
@@ -63,56 +72,58 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     return Promise.resolve();
   }
 
+  public updateConfig(config: Partial<SlasherConfig>): void {
+    this.penalties = merge(this.penalties, pick(config, ...EpochPruneWatcherPenaltiesConfigKeys));
+    this.log.verbose('EpochPruneWatcher config updated', this.penalties);
+  }
+
   private handlePruneL2Blocks(event: L2BlockPruneEvent): void {
     const { blocks, epochNumber } = event;
-    this.log.info(`Detected chain prune. Validating epoch ${epochNumber}`);
-
-    this.validateBlocks(blocks)
-      .then(async () => {
-        this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
-        const validators = await this.getValidatorsForEpoch(epochNumber);
-        // need to specify return type to be able to return offense as undefined later on
-        const result: { validators: EthAddress[]; offense: OffenseType | undefined } = {
-          validators,
-          offense: OffenseType.VALID_EPOCH_PRUNED,
-        };
-        return result;
-      })
-      .catch(async error => {
-        if (error instanceof TransactionsNotAvailableError) {
-          this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, error);
-          const validators = await this.getValidatorsForEpoch(epochNumber);
-          return {
-            validators,
-            offense: OffenseType.DATA_WITHHOLDING,
-          };
-        } else {
-          this.log.error(`Error while validating pruned epoch ${epochNumber}. Will not want to slash.`, error);
-          return {
-            validators: [],
-            offense: undefined,
-          };
-        }
-      })
-      .then(({ validators, offense }) => {
-        if (validators.length === 0 || offense === undefined) {
-          return;
-        }
-        const args = this.validatorsToSlashingArgs(validators, offense, BigInt(epochNumber));
-        this.log.info(`Slash for epoch ${epochNumber} created`, args);
-        this.emit(WANT_TO_SLASH_EVENT, args);
-      })
-      .catch(error => {
-        // This can happen if we fail to get the validators for the epoch.
-        this.log.error('Error while creating slash for epoch', error);
-      });
+    void this.processPruneL2Blocks(blocks, epochNumber).catch(err =>
+      this.log.error('Error processing pruned L2 blocks', err, { epochNumber }),
+    );
+  }
+
+  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, 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: EpochNumber): Promise<void> {
+    try {
+      const l1Constants = this.epochCache.getL1Constants();
+      const epochBlocks = blocks.filter(b => getEpochAtSlot(b.slot, 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);
+      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) {
+      if (error instanceof TransactionsNotAvailableError) {
+        this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, {
+          message: error.message,
+        });
+        await this.emitSlashForEpoch(OffenseType.DATA_WITHHOLDING, epochNumber);
+      } else {
+        this.log.error(`Error while validating pruned epoch ${epochNumber}. Will not want to slash.`, error);
+      }
+    }
   }
 
   public async validateBlocks(blocks: L2Block[]): Promise<void> {
     if (blocks.length === 0) {
       return;
     }
-    const fork = await this.blockBuilder.getFork(blocks[0].header.globalVariables.blockNumber - 1);
+    const fork = await this.blockBuilder.getFork(BlockNumber(blocks[0].header.globalVariables.blockNumber - 1));
     try {
       for (const block of blocks) {
         await this.validateBlock(block, fork);
@@ -134,9 +145,10 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
       throw new TransactionsNotAvailableError(missingTxs);
     }
 
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockFromL1.number);
+    const checkpointNumber = CheckpointNumber.fromBlockNumber(blockFromL1.number);
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
     const { block, failedTxs, numTxs } = await this.blockBuilder.buildBlock(
-      txs as Tx[],
+      txs,
       l1ToL2Messages,
       blockFromL1.header.globalVariables,
       {},
@@ -154,7 +166,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}`);
@@ -166,7 +178,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
@@ -176,7 +188,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
       validator: v,
       amount: penalty,
       offenseType,
-      epochOrSlot,
+      epochOrSlot: BigInt(epochOrSlot),
     }));
   }
 }