@aztec-labs/slasher 6.0.0-nightly.20260829

package/src/stores/offenses_store.ts

@@ -0,0 +1,173 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec-labs/kv-store';
+import {
+  type Offense,
+  type OffenseIdentifier,
+  deserializeOffense,
+  getRoundForOffense,
+  serializeOffense,
+} from '@aztec-labs/stdlib/slashing';
+
+export const SCHEMA_VERSION = 1;
+
+type ClearOffensesFilter = Pick<Offense, 'offenseType' | 'epochOrSlot'> & {
+  validators?: Offense['validator'][];
+};
+
+export class SlasherOffensesStore {
+  /** Map from offense key to offense data */
+  private offenses: AztecAsyncMap<string, Buffer>;
+
+  /** Multimap from round to offense keys */
+  private roundsOffenses: AztecAsyncMultiMap<string, string>;
+
+  private log = createLogger('slasher:store:offenses');
+
+  constructor(
+    private kvStore: AztecAsyncKVStore,
+    private settings: {
+      slashingRoundSize: number;
+      epochDuration: number;
+      slashOffenseExpirationRounds?: number;
+    },
+  ) {
+    this.offenses = kvStore.openMap('offenses');
+    this.roundsOffenses = kvStore.openMultiMap('rounds-offenses');
+  }
+
+  /** Returns all offenses */
+  public async getOffenses(): Promise<Offense[]> {
+    const offenses: Offense[] = [];
+    for await (const [, buffer] of this.offenses.entriesAsync()) {
+      offenses.push(deserializeOffense(buffer));
+    }
+    return offenses;
+  }
+
+  /** Returns all offenses tracked for the given round */
+  public async getOffensesForRound(round: bigint): Promise<Offense[]> {
+    const offenses: Offense[] = [];
+    for await (const key of this.roundsOffenses.getValuesAsync(this.getRoundKey(round))) {
+      const buffer = await this.offenses.getAsync(key);
+      if (buffer) {
+        const offense = deserializeOffense(buffer);
+        offenses.push(offense);
+      }
+    }
+    return offenses;
+  }
+
+  /** Returns whether we have seen this offense */
+  public async hasOffense(offense: OffenseIdentifier): Promise<boolean> {
+    const key = this.getOffenseKey(offense);
+    return (await this.offenses.getAsync(key)) !== undefined;
+  }
+
+  /** Adds a new offense. Returns false if the offense is already pending. */
+  public async addOffense(offense: Offense): Promise<boolean> {
+    const key = this.getOffenseKey(offense);
+    const round = getRoundForOffense(offense, this.settings);
+    const added = await this.kvStore.transactionAsync(async () => {
+      if ((await this.offenses.getAsync(key)) !== undefined) {
+        return false;
+      }
+
+      await this.offenses.set(key, serializeOffense(offense));
+      await this.roundsOffenses.set(this.getRoundKey(round), key);
+      return true;
+    });
+
+    if (added) {
+      this.log.trace(`Adding pending offense ${key} for round ${round}`);
+    }
+
+    return added;
+  }
+
+  /** Removes pending offenses matching the given offense type, epoch/slot, and optional validators. */
+  public async clearOffenses(filter: ClearOffensesFilter): Promise<number> {
+    return await this.kvStore.transactionAsync(async () => {
+      const offensesToClear = new Map<string, Offense>();
+
+      if (filter.validators && filter.validators.length > 0) {
+        for (const validator of filter.validators) {
+          const identifier = { validator, offenseType: filter.offenseType, epochOrSlot: filter.epochOrSlot };
+          const key = this.getOffenseKey(identifier);
+          const buffer = await this.offenses.getAsync(key);
+          if (buffer) {
+            offensesToClear.set(key, deserializeOffense(buffer));
+          }
+        }
+      } else {
+        for await (const [key, buffer] of this.offenses.entriesAsync()) {
+          const offense = deserializeOffense(buffer);
+          if (offense.offenseType === filter.offenseType && offense.epochOrSlot === filter.epochOrSlot) {
+            offensesToClear.set(key, offense);
+          }
+        }
+      }
+
+      if (offensesToClear.size === 0) {
+        return 0;
+      }
+
+      for (const [key, offense] of offensesToClear) {
+        const round = getRoundForOffense(offense, this.settings);
+        await this.offenses.delete(key);
+        await this.roundsOffenses.deleteValue(this.getRoundKey(round), key);
+        this.log.trace(`Cleared pending offense ${key} for round ${round}`);
+      }
+
+      return offensesToClear.size;
+    });
+  }
+
+  /** Prunes all offenses expired from the store */
+  public async clearExpiredOffenses(currentRound: bigint): Promise<number> {
+    const expirationRounds = this.settings.slashOffenseExpirationRounds ?? 0;
+    if (expirationRounds <= 0) {
+      return 0; // No expiration configured
+    }
+
+    const expiredBefore = currentRound - BigInt(expirationRounds);
+    if (expiredBefore < 0) {
+      return 0; // Not enough rounds have passed to expire anything
+    }
+
+    return await this.kvStore.transactionAsync(async () => {
+      // Collect expired offenses and rounds
+      const expiredRoundKeys = new Set<string>();
+      const expiredOffenseKeys = new Set<string>();
+      for await (const [roundKey, offenseKey] of this.roundsOffenses.entriesAsync({
+        end: this.getRoundKey(expiredBefore),
+      })) {
+        expiredOffenseKeys.add(offenseKey);
+        expiredRoundKeys.add(roundKey);
+      }
+
+      if (expiredOffenseKeys.size === 0 && expiredRoundKeys.size === 0) {
+        return 0; // Nothing to clean up
+      }
+
+      for (const key of expiredOffenseKeys) {
+        this.log.trace(`Deleting offense ${key}`);
+        await this.offenses.delete(key);
+      }
+      for (const roundKey of expiredRoundKeys) {
+        this.log.trace(`Deleting round info for ${roundKey}`);
+        await this.roundsOffenses.delete(roundKey);
+      }
+
+      return expiredOffenseKeys.size;
+    });
+  }
+
+  /** Generate a unique key for an offense */
+  private getOffenseKey(offense: OffenseIdentifier): string {
+    return `${offense.validator.toString()}:${offense.offenseType}:${offense.epochOrSlot}`;
+  }
+
+  private getRoundKey(round: bigint): string {
+    return round.toString().padStart(16, '0');
+  }
+}

package/src/stores/schema_version.ts

@@ -0,0 +1 @@
+export const SCHEMA_VERSION = 1;

package/src/test/dummy_watcher.ts

@@ -0,0 +1,20 @@
+import type { SlasherConfig } from '@aztec-labs/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

@@ -0,0 +1,35 @@
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { TypedEventEmitter } from '@aztec-labs/foundation/types';
+import { OffenseType } from '@aztec-labs/stdlib/slashing';
+
+import type { SlasherConfig } from './config.js';
+
+export const WANT_TO_SLASH_EVENT = 'want-to-slash' as const;
+export const WANT_TO_CLEAR_SLASH_EVENT = 'want-to-clear-slash' as const;
+
+export interface WantToSlashArgs {
+  validator: EthAddress;
+  amount: bigint;
+  offenseType: OffenseType;
+  epochOrSlot: bigint; // Epoch number for epoch-based offenses, slot number for slot-based
+}
+
+export interface WantToClearSlashArgs {
+  offenseType: OffenseType;
+  epochOrSlot: bigint; // Epoch number for epoch-based offenses, slot number for slot-based
+  validators?: EthAddress[];
+}
+
+// Event map for specific, known events of a watcher
+export interface WatcherEventMap {
+  [WANT_TO_SLASH_EVENT]: (args: WantToSlashArgs[]) => void;
+  [WANT_TO_CLEAR_SLASH_EVENT]: (args: WantToClearSlashArgs[]) => void;
+}
+
+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

@@ -0,0 +1,199 @@
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { merge, pick } from '@aztec-labs/foundation/collection';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec-labs/foundation/log';
+import {
+  type DescendentOfInvalidAttestationsCheckpointEvent,
+  type InvalidCheckpointDetectedEvent,
+  type L2BlockSourceEventEmitter,
+  L2BlockSourceEvents,
+  type ValidateCheckpointNegativeResult,
+} from '@aztec-labs/stdlib/block';
+import { getEpochAtSlot } from '@aztec-labs/stdlib/epoch-helpers';
+import { OffenseType, getOffenseTypeName } from '@aztec-labs/stdlib/slashing';
+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 = [
+  'slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty',
+  'slashProposeInvalidAttestationsPenalty',
+] as const;
+
+type AttestationsBlockWatcherConfig = Pick<SlasherConfig, (typeof AttestationsBlockWatcherConfigKeys)[number]>;
+
+/**
+ * Watches the archiver for checkpoints whose publication is itself a slashable offense.
+ *
+ * Two cases are handled, both targeting the proposer of the offending checkpoint:
+ *
+ * - Invalid-attestations checkpoint: the proposer published a checkpoint to L1 whose
+ *   attestations are either insufficient (below quorum) or incorrect (signature from a
+ *   non-committee member, malformed signature, etc.). Slashed via
+ *   {@link OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS} or
+ *   {@link OffenseType.PROPOSED_INCORRECT_ATTESTATIONS}.
+ *
+ * - Descendant of an invalid checkpoint: the proposer published a checkpoint that extends a
+ *   previously-rejected one. The descendant may itself have valid attestations, but it is still
+ *   unusable. Triggered by the archiver's  `CheckpointBuiltOnInvalidAncestorDetected` event
+ *   when the descendant has valid attestations (skipped before ingestion). Slashes the descendant's
+ *   proposer via {@link OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS}.
+ */
+export class AttestationsBlockWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
+  private log: Logger;
+  private config: AttestationsBlockWatcherConfig;
+
+  private boundHandleInvalidCheckpoint = (event: InvalidCheckpointDetectedEvent) => {
+    try {
+      this.handleInvalidCheckpoint(event);
+    } catch (err) {
+      this.log.error('Error handling invalid checkpoint', err, {
+        ...event.validationResult,
+        reason: event.validationResult.reason,
+      });
+    }
+  };
+
+  private boundHandleDescendantOfInvalid = (event: DescendentOfInvalidAttestationsCheckpointEvent) => {
+    this.handleDescendantOfInvalid(event).catch(err => {
+      this.log.error('Error handling descendant of invalid checkpoint', err, {
+        checkpointNumber: event.checkpoint.checkpointNumber,
+        ancestorCheckpointNumber: event.ancestorCheckpointNumber,
+      });
+    });
+  };
+
+  constructor(
+    private l2BlockSource: L2BlockSourceEventEmitter,
+    private epochCache: EpochCache,
+    config: AttestationsBlockWatcherConfig,
+    bindings?: LoggerBindings,
+  ) {
+    super();
+    this.log = createLogger('slasher:attestations-block-watcher', bindings);
+    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() {
+    this.l2BlockSource.events.on(
+      L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
+      this.boundHandleInvalidCheckpoint,
+    );
+    this.l2BlockSource.events.on(
+      L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected,
+      this.boundHandleDescendantOfInvalid,
+    );
+    return Promise.resolve();
+  }
+
+  public stop() {
+    this.l2BlockSource.events.removeListener(
+      L2BlockSourceEvents.InvalidAttestationsCheckpointDetected,
+      this.boundHandleInvalidCheckpoint,
+    );
+    this.l2BlockSource.events.removeListener(
+      L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected,
+      this.boundHandleDescendantOfInvalid,
+    );
+    return Promise.resolve();
+  }
+
+  /** Event handler for invalid checkpoints as reported by the archiver. Public for testing purposes. */
+  public handleInvalidCheckpoint(event: InvalidCheckpointDetectedEvent): void {
+    const { validationResult } = event;
+    const { reason, checkpoint } = validationResult;
+
+    this.log.verbose(`Detected invalid checkpoint ${checkpoint.checkpointNumber}`, {
+      ...checkpoint,
+      reason: validationResult.valid === false ? validationResult.reason : 'unknown',
+    });
+
+    const { checkpointNumber, slotNumber: slot } = checkpoint;
+    const epochCommitteeInfo = { ...validationResult, isEscapeHatchOpen: false };
+    const proposer = this.epochCache.getProposerFromEpochCommittee(epochCommitteeInfo, slot);
+
+    if (!proposer) {
+      this.log.warn(`No proposer found for checkpoint ${checkpointNumber} at slot ${slot}`);
+      return;
+    }
+
+    const offense = this.getOffenseFromInvalidationReason(reason);
+    const amount = this.config.slashProposeInvalidAttestationsPenalty;
+    const args: WantToSlashArgs = {
+      validator: proposer,
+      amount,
+      offenseType: offense,
+      epochOrSlot: BigInt(slot),
+    };
+
+    this.log.info(`Detected invalid attestations checkpoint proposer offense`, {
+      ...checkpoint,
+      reason,
+      validator: args.validator.toString(),
+      amount: args.amount,
+      offenseType: getOffenseTypeName(args.offenseType),
+      epochOrSlot: args.epochOrSlot,
+    });
+
+    this.emit(WANT_TO_SLASH_EVENT, [args]);
+  }
+
+  /**
+   * Event handler for valid-attestations checkpoints that build on a previously-rejected ancestor.
+   * The archiver emits this when ingesting the descendant, and we slash its proposer.
+   */
+  public async handleDescendantOfInvalid(event: DescendentOfInvalidAttestationsCheckpointEvent): Promise<void> {
+    const { checkpoint, ancestorCheckpointNumber, ancestorArchiveRoot } = event;
+
+    const slot = checkpoint.slotNumber;
+    const epoch = EpochNumber(getEpochAtSlot(slot, this.epochCache.getL1Constants()));
+    const epochCommitteeInfo = await this.epochCache.getCommitteeForEpoch(epoch);
+    const proposer = this.epochCache.getProposerFromEpochCommittee({ ...epochCommitteeInfo, epoch }, slot);
+
+    if (!proposer) {
+      this.log.warn(
+        `No proposer found for invalid descendant checkpoint ${checkpoint.checkpointNumber} at slot ${slot}`,
+      );
+      return;
+    }
+
+    const args: WantToSlashArgs = {
+      validator: proposer,
+      amount: this.config.slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty,
+      offenseType: OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS,
+      epochOrSlot: BigInt(slot),
+    };
+
+    this.log.info(`Detected invalid descendant checkpoint proposer offense`, {
+      ...checkpoint,
+      ancestorCheckpointNumber,
+      ancestorArchiveRoot: ancestorArchiveRoot.toString(),
+      validator: args.validator.toString(),
+      amount: args.amount,
+      offenseType: getOffenseTypeName(args.offenseType),
+      epochOrSlot: args.epochOrSlot,
+    });
+
+    this.emit(WANT_TO_SLASH_EVENT, [args]);
+  }
+
+  private getOffenseFromInvalidationReason(reason: ValidateCheckpointNegativeResult['reason']): OffenseType {
+    switch (reason) {
+      case 'invalid-attestation':
+        return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
+      case 'insufficient-attestations':
+        return OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS;
+      default: {
+        const _: never = reason;
+        return OffenseType.UNKNOWN;
+      }
+    }
+  }
+}

package/src/watchers/attested_invalid_proposal_watcher.ts

@@ -0,0 +1,167 @@
+import type { EpochCacheInterface } from '@aztec-labs/epoch-cache';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { merge, pick } from '@aztec-labs/foundation/collection';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { FifoSet } from '@aztec-labs/foundation/fifo-set';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { RunningPromise } from '@aztec-labs/foundation/running-promise';
+import type { L2BlockSource } from '@aztec-labs/stdlib/block';
+import type { P2PClient, SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+import type { CheckpointAttestation } from '@aztec-labs/stdlib/p2p';
+import { OffenseType, getOffenseTypeName } from '@aztec-labs/stdlib/slashing';
+import EventEmitter from 'node:events';
+
+import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
+
+const AttestedInvalidProposalWatcherConfigKeys = ['slashAttestInvalidCheckpointProposalPenalty'] as const;
+
+const SCAN_SLOT_LAG = 1;
+const DEFAULT_SCAN_SLOT_LOOKBACK = 4;
+const MAX_TRACKED_BAD_ATTESTATIONS = 10_000;
+
+type AttestedInvalidProposalWatcherConfig = Pick<
+  SlasherConfig,
+  (typeof AttestedInvalidProposalWatcherConfigKeys)[number]
+>;
+
+type P2PCheckpointAttestationSource = Pick<P2PClient, 'getCheckpointAttestationsForSlot'>;
+
+type AttestedInvalidProposalWatcherOptions = {
+  scanSlotLookback?: number;
+  log?: Logger;
+};
+
+export type InvalidProposalSlotSource = {
+  hasInvalidProposals(slot: SlotNumber): boolean;
+  hasProposalEquivocation(slot: SlotNumber): boolean;
+};
+
+export class AttestedInvalidProposalWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
+  private readonly log: Logger;
+  private readonly runningPromise: RunningPromise;
+  private readonly emittedOffenses = FifoSet.withLimit<string>(MAX_TRACKED_BAD_ATTESTATIONS);
+  private readonly scanSlotLookback: number;
+  private config: AttestedInvalidProposalWatcherConfig;
+  private lastScannedSlot: SlotNumber | undefined;
+
+  constructor(
+    private readonly p2pClient: P2PCheckpointAttestationSource,
+    private readonly invalidProposalSlotSource: InvalidProposalSlotSource,
+    private readonly l2BlockSource: Pick<L2BlockSource, 'getSyncedL2SlotNumber'>,
+    private readonly epochCache: Pick<EpochCacheInterface, 'getSlotNow' | 'getL1Constants'>,
+    config: AttestedInvalidProposalWatcherConfig,
+    options: AttestedInvalidProposalWatcherOptions = {},
+  ) {
+    super();
+    const constants = epochCache.getL1Constants();
+    this.log = options.log ?? createLogger('attested-invalid-proposal-watcher');
+    this.config = pick(config, ...AttestedInvalidProposalWatcherConfigKeys);
+    this.scanSlotLookback = Math.max(1, options.scanSlotLookback ?? DEFAULT_SCAN_SLOT_LOOKBACK);
+
+    const intervalMs = Math.max(1000, (constants.ethereumSlotDuration * 1000) / 4);
+    this.runningPromise = new RunningPromise(() => this.scan(), this.log, intervalMs);
+    this.log.info('AttestedInvalidProposalWatcher initialized', { scanSlotLookback: this.scanSlotLookback });
+  }
+
+  public updateConfig(config: Partial<SlasherConfig>): void {
+    this.config = merge(this.config, pick(config, ...AttestedInvalidProposalWatcherConfigKeys));
+    this.log.verbose('AttestedInvalidProposalWatcher config updated', this.config);
+  }
+
+  public start(): Promise<void> {
+    this.runningPromise.start();
+    return Promise.resolve();
+  }
+
+  public stop(): Promise<void> {
+    return this.runningPromise.stop();
+  }
+
+  public async scan(): Promise<void> {
+    const currentSlot = (await this.l2BlockSource.getSyncedL2SlotNumber()) ?? this.epochCache.getSlotNow();
+    // genesis
+    if (currentSlot <= SlotNumber(SCAN_SLOT_LAG)) {
+      return;
+    }
+
+    const newestSlotToConsider = SlotNumber(currentSlot - SCAN_SLOT_LAG);
+    const oldestSlot =
+      this.lastScannedSlot === undefined
+        ? SlotNumber(Math.max(0, newestSlotToConsider - this.scanSlotLookback + 1))
+        : SlotNumber(this.lastScannedSlot + 1);
+    if (oldestSlot > newestSlotToConsider) {
+      return;
+    }
+
+    for (let slot = oldestSlot; slot <= newestSlotToConsider; slot++) {
+      await this.scanSlot(slot);
+    }
+
+    this.lastScannedSlot = newestSlotToConsider;
+  }
+
+  /** Scans a single invalid-proposal slot. */
+  public async scanSlot(slot: SlotNumber): Promise<void> {
+    if (
+      this.invalidProposalSlotSource.hasProposalEquivocation(slot) ||
+      !this.invalidProposalSlotSource.hasInvalidProposals(slot)
+    ) {
+      return;
+    }
+
+    let attestations: CheckpointAttestation[];
+    try {
+      attestations = await this.p2pClient.getCheckpointAttestationsForSlot(slot);
+    } catch (err) {
+      this.log.warn('Error getting checkpoint attestations for invalid proposal slot', { err, slot });
+      return;
+    }
+
+    const slashArgs = attestations
+      .map(attestation => this.getSlashArgs(slot, attestation))
+      .filter((args): args is WantToSlashArgs => args !== undefined)
+      .filter(args => this.markAsNewOffense(args));
+
+    if (slashArgs.length === 0) {
+      return;
+    }
+
+    this.log.info('Detected attestations to invalid checkpoint proposal', {
+      slot,
+      offenses: slashArgs.map(args => ({
+        validator: args.validator.toString(),
+        amount: args.amount,
+        offenseType: getOffenseTypeName(args.offenseType),
+        epochOrSlot: args.epochOrSlot,
+      })),
+    });
+    this.emit(WANT_TO_SLASH_EVENT, slashArgs);
+  }
+
+  private getSlashArgs(slot: SlotNumber, attestation: CheckpointAttestation): WantToSlashArgs | undefined {
+    const attester = attestation.getSender();
+    if (!attester) {
+      this.log.warn('Cannot slash checkpoint attestation with invalid signature', {
+        slot,
+        archive: attestation.archive.toString(),
+      });
+      return undefined;
+    }
+
+    return this.getSlashArgsForAttester(slot, attester);
+  }
+
+  private getSlashArgsForAttester(slot: SlotNumber, attester: EthAddress): WantToSlashArgs {
+    return {
+      validator: attester,
+      amount: this.config.slashAttestInvalidCheckpointProposalPenalty,
+      offenseType: OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL,
+      epochOrSlot: BigInt(slot),
+    };
+  }
+
+  private markAsNewOffense(args: WantToSlashArgs): boolean {
+    const key = `${args.validator.toString()}-${args.offenseType}-${args.epochOrSlot}`;
+    return this.emittedOffenses.addIfAbsent(key);
+  }
+}