@aztec/slasher 0.0.1-commit.24de95ac → 0.0.1-commit.2e2504e2

package/src/empire_slasher_client.ts

@@ -1,9 +1,9 @@
-import { EmpireSlashingProposerContract, RollupContract, SlasherContract } from '@aztec/ethereum';
+import { EmpireSlashingProposerContract, RollupContract, SlasherContract } from '@aztec/ethereum/contracts';
 import { sumBigint } from '@aztec/foundation/bigint';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { compactArray, filterAsync, maxBy, pick } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { sleep } from '@aztec/foundation/sleep';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
@@ -195,13 +195,6 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
     this.roundMonitor.stop();
     await this.offensesCollector.stop();
 
-    // Viem calls eth_uninstallFilter under the hood when uninstalling event watchers, but these calls are not awaited,
-    // meaning that any error that happens during the uninstallation will not be caught. This causes errors during jest teardowns,
-    // where we stop anvil after all other processes are stopped, so sometimes the eth_uninstallFilter call fails because anvil
-    // is already stopped. We add a sleep here to give the uninstallation some time to complete, but the proper fix is for
-    // viem to await the eth_uninstallFilter calls, or to catch any errors that happen during the uninstallation.
-    // See https://github.com/wevm/viem/issues/3714.
-    await sleep(2000);
     this.log.info('Empire Slasher client stopped');
   }
 
@@ -369,7 +362,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
    * @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, proposePayloadActions] = await Promise.all([
       this.getExecutePayloadAction(slotNumber),
       this.getProposePayloadActions(slotNumber),
@@ -379,7 +372,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
   }
 
   /** Returns an execute payload action if there are any payloads ready to be executed */
-  protected async getExecutePayloadAction(slotNumber: bigint): Promise<ProposerSlashAction | undefined> {
+  protected async getExecutePayloadAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined> {
     const { round } = this.roundMonitor.getRoundForSlot(slotNumber);
     const toRemove: PayloadWithRound[] = [];
 
@@ -430,7 +423,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
   }
 
   /** Returns a vote or create payload action based on payload scoring */
-  protected async getProposePayloadActions(slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  protected async getProposePayloadActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     // Compute what round we are in based on the slot number
     const { round, votingSlot } = this.roundMonitor.getRoundForSlot(slotNumber);
     const { slashingRoundSize: roundSize, slashingQuorumSize: quorumSize } = this.settings;
@@ -473,7 +466,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
     // Find the best existing payload. We filter out those that have no chance of winning given how many voting
     // slots are left in the round, and then filter by those we agree with.
     const feasiblePayloads = existingPayloads.filter(
-      p => BigInt(quorumSize) - p.votes <= BigInt(roundSize) - votingSlot,
+      p => BigInt(quorumSize) - p.votes <= BigInt(roundSize) - BigInt(votingSlot),
     );
     const requiredOffenses = await this.getPendingUncontroversialOffensesForRound(round);
     const agreedPayloads = await filterAsync(feasiblePayloads, p => this.agreeWithPayload(p, round, requiredOffenses));

package/src/factory/create_facade.ts

@@ -1,6 +1,7 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import type { L1ReaderConfig, ViemClient } from '@aztec/ethereum';
 import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import type { ViemClient } from '@aztec/ethereum/types';
 import { unique } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
@@ -30,7 +31,7 @@ export async function createSlasherFacade(
     throw new Error('Cannot initialize SlasherClient without a Rollup address');
   }
 
-  const kvStore = await createStore('slasher', SCHEMA_VERSION, config, createLogger('slasher:lmdb'));
+  const kvStore = await createStore('slasher', SCHEMA_VERSION, config, logger.getBindings());
   const rollup = new RollupContract(l1Client, l1Contracts.rollupAddress);
 
   const slashValidatorsNever = config.slashSelfAllowed

package/src/factory/create_implementation.ts

@@ -1,10 +1,10 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import type { ViemClient } from '@aztec/ethereum';
 import {
   EmpireSlashingProposerContract,
   RollupContract,
   TallySlashingProposerContract,
 } from '@aztec/ethereum/contracts';
+import type { ViemClient } from '@aztec/ethereum/types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';

package/src/factory/get_settings.ts

@@ -1,4 +1,4 @@
-import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
+import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
 
 import type { TallySlasherSettings } from '../tally_slasher_client.js';
 

package/src/generated/slasher-defaults.ts

@@ -0,0 +1,21 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+
+/** Default slasher configuration values from network-defaults.yml */
+export const slasherDefaultEnv = {
+  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
+  SLASH_MAX_PENALTY_PERCENTAGE: 2,
+  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 50,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_PRUNE_PENALTY: 10000000000000000000,
+  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
+  SLASH_INACTIVITY_PENALTY: 10000000000000000000,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
+  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
+} as const;

package/src/null_slasher_client.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
 
 import type { SlasherConfig } from './config.js';
@@ -30,7 +31,7 @@ export class NullSlasherClient implements SlasherClientInterface {
     this.config = { ...this.config, ...config };
   }
 
-  public getProposerActions(_slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  public getProposerActions(_slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     return Promise.resolve([]);
   }
 

package/src/slash_offenses_collector.ts

@@ -85,7 +85,11 @@ export class SlashOffensesCollector {
         }
       }
 
-      this.log.info(`Adding pending offense for validator ${arg.validator}`, pendingOffense);
+      this.log.info(`Adding pending offense for validator ${arg.validator}`, {
+        ...pendingOffense,
+        epochOrSlot: pendingOffense.epochOrSlot.toString(),
+        amount: pendingOffense.amount.toString(),
+      });
       await this.offensesStore.addPendingOffense(pendingOffense);
     }
   }

package/src/slash_round_monitor.ts

@@ -1,3 +1,4 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { Prettify } from '@aztec/foundation/types';
@@ -48,12 +49,12 @@ export class SlashRoundMonitor {
   }
 
   /** Returns the slashing round number and the voting slot within the round based on the L2 chain slot */
-  public getRoundForSlot(slotNumber: bigint): { round: bigint; votingSlot: bigint } {
+  public getRoundForSlot(slotNumber: SlotNumber): { round: bigint; votingSlot: SlotNumber } {
     return getRoundForSlot(slotNumber, this.settings);
   }
 
   /** Returns the current slashing round and voting slot within the round */
-  public getCurrentRound(): { round: bigint; votingSlot: bigint } {
+  public getCurrentRound(): { round: bigint; votingSlot: SlotNumber } {
     const now = this.dateProvider.nowInSeconds();
     const currentSlot = getSlotAtTimestamp(BigInt(now), this.settings);
     return this.getRoundForSlot(currentSlot);

package/src/slasher_client_facade.ts

@@ -1,6 +1,7 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import type { ViemClient } from '@aztec/ethereum';
 import { RollupContract } from '@aztec/ethereum/contracts';
+import type { ViemClient } from '@aztec/ethereum/types';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
@@ -73,7 +74,7 @@ export class SlasherClientFacade implements SlasherClientInterface {
     return this.client?.getPendingOffenses() ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 
-  public getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  public getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     return this.client?.getProposerActions(slotNumber) ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 

package/src/slasher_client_interface.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
 import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
 
@@ -38,7 +39,7 @@ export interface SlasherClientInterface {
    * @param slotNumber - The current slot number
    * @returns The actions to take
    */
-  getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]>;
+  getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
 
   /** Returns the current config */
   getConfig(): SlasherConfig;

package/src/stores/offenses_store.ts

@@ -76,9 +76,11 @@ export class SlasherOffensesStore {
   /** Adds a new offense (defaults to pending, but will be slashed if markAsSlashed had been called for it) */
   public async addPendingOffense(offense: Offense): Promise<void> {
     const key = this.getOffenseKey(offense);
-    await this.offenses.set(key, serializeOffense(offense));
     const round = getRoundForOffense(offense, this.settings);
-    await this.roundsOffenses.set(this.getRoundKey(round), key);
+    await this.kvStore.transactionAsync(async () => {
+      await this.offenses.set(key, serializeOffense(offense));
+      await this.roundsOffenses.set(this.getRoundKey(round), key);
+    });
     this.log.trace(`Adding pending offense ${key} for round ${round}`);
   }
 

package/src/stores/payloads_store.ts

@@ -118,10 +118,13 @@ export class SlasherPayloadsStore {
 
   public async incrementPayloadVotes(payloadAddress: EthAddress, round: bigint): Promise<bigint> {
     const key = this.getPayloadVotesKey(round, payloadAddress);
-    const currentVotes = (await this.roundPayloadVotes.getAsync(key)) || 0n;
-    const newVotes = currentVotes + 1n;
-    await this.roundPayloadVotes.set(key, newVotes);
-    return newVotes;
+    let newVotes: bigint;
+    await this.kvStore.transactionAsync(async () => {
+      const currentVotes = (await this.roundPayloadVotes.getAsync(key)) || 0n;
+      newVotes = currentVotes + 1n;
+      await this.roundPayloadVotes.set(key, newVotes);
+    });
+    return newVotes!;
   }
 
   public async addPayload(payload: SlashPayloadRound): Promise<void> {

package/src/tally_slasher_client.ts

@@ -2,9 +2,9 @@ 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;
@@ -233,7 +231,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
    */
   private async tryGetRoundExecuteAction(
     executableRound: bigint,
-    slotNumber: bigint,
+    slotNumber: SlotNumber,
   ): Promise<ProposerSlashAction | undefined> {
     let logData: Record<string, unknown> = { executableRound, slotNumber };
     this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
@@ -280,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,
       });
@@ -302,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);
@@ -347,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);
     }