@aztec/slasher 0.0.1-commit.993d52e → 0.0.1-commit.9a89641

package/src/{tally_slasher_client.ts → slasher_client.ts}

@@ -1,6 +1,6 @@
 import { EthAddress } from '@aztec/aztec.js/addresses';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { RollupContract, SlasherContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import { RollupContract, SlasherContract, SlashingProposerContract } 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';
@@ -13,13 +13,16 @@ import {
   OffenseType,
   type ProposerSlashAction,
   type ProposerSlashActionProvider,
-  type SlashPayloadRound,
   getEpochsForRound,
+  getOffenseTypeName,
   getSlashConsensusVotesFromOffenses,
 } from '@aztec/stdlib/slashing';
+import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { Hex } from 'viem';
 
+import { SlasherMetrics } from './metrics.js';
+import { OwnValidatorSlashMonitor } from './own_validator_slash_monitor.js';
 import {
   SlashOffensesCollector,
   type SlashOffensesCollectorConfig,
@@ -30,8 +33,8 @@ import type { SlasherClientInterface } from './slasher_client_interface.js';
 import type { SlasherOffensesStore } from './stores/offenses_store.js';
 import type { Watcher } from './watcher.js';
 
-/** Settings used in the tally slasher client, loaded from the L1 contracts during initialization */
-export type TallySlasherSettings = Prettify<
+/** Settings used in the slasher client, loaded from the L1 contracts during initialization */
+export type SlasherSettings = Prettify<
   SlashRoundMonitorSettings &
     SlashOffensesCollectorSettings & {
       slashingLifetimeInRounds: number;
@@ -45,11 +48,22 @@ export type TallySlasherSettings = Prettify<
     }
 >;
 
-export type TallySlasherClientConfig = SlashOffensesCollectorConfig &
-  Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack'>;
+export type SlasherClientConfig = SlashOffensesCollectorConfig &
+  Pick<
+    SlasherConfig,
+    'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack' | 'slashMaxPayloadSize'
+  >;
+
+type AlwaysSlashOffense = {
+  validator: EthAddress;
+  amount: bigint;
+  offenseType: OffenseType.UNKNOWN;
+};
+
+type SlashVoteOffense = Offense | AlwaysSlashOffense;
 
 /**
- * The Tally Slasher client is responsible for managing slashable offenses using
+ * The Slasher client is responsible for managing slashable offenses using
  * the consensus-based slashing model where proposers vote on individual validator offenses.
  *
  * The client subscribes to several slash watchers that emit offenses and tracks them. When the slasher is the
@@ -73,43 +87,41 @@ export type TallySlasherClientConfig = SlashOffensesCollectorConfig &
  * - Validators that reach the quorum threshold are slashed. A vote for slashing N units is also considered
  * a vote for slashing N-1, N-2, ..., 1 units. The system slashes for the largest amount that reaches quorum.
  * - The client monitors executable rounds and triggers execution when appropriate.
- *
- * Differences from Empire model
- * - No fixed slash payloads - votes are for individual validator offenses encoded in bytes
- * - The L1 contract determines which offenses reach quorum rather than nodes agreeing on a payload
- * - Proposers vote directly on which validators to slash and by how much
- * - Uses a slash offset to vote on validators from past rounds (e.g., round N votes on round N-2)
  */
-export class TallySlasherClient implements ProposerSlashActionProvider, SlasherClientInterface {
+export class SlasherClient implements ProposerSlashActionProvider, SlasherClientInterface {
   protected unwatchCallbacks: (() => void)[] = [];
   protected roundMonitor: SlashRoundMonitor;
   protected offensesCollector: SlashOffensesCollector;
+  protected readonly ownValidatorMonitor: OwnValidatorSlashMonitor;
 
   constructor(
-    private config: TallySlasherClientConfig,
-    private settings: TallySlasherSettings,
-    private tallySlashingProposer: TallySlashingProposerContract,
+    private config: SlasherClientConfig,
+    private settings: SlasherSettings,
+    private slashingProposer: SlashingProposerContract,
     private slasher: SlasherContract,
     private rollup: RollupContract,
     watchers: Watcher[],
     private epochCache: EpochCache,
     private dateProvider: DateProvider,
     private offensesStore: SlasherOffensesStore,
+    private readonly ownValidators: EthAddress[] = [],
     private log = createLogger('slasher:consensus'),
+    private readonly metrics = new SlasherMetrics(getTelemetryClient()),
   ) {
     this.roundMonitor = new SlashRoundMonitor(settings, dateProvider);
     this.offensesCollector = new SlashOffensesCollector(config, settings, watchers, offensesStore);
+    this.ownValidatorMonitor = new OwnValidatorSlashMonitor(slashingProposer, settings, ownValidators, this.metrics);
   }
 
   public async start() {
-    this.log.debug('Starting Tally Slasher client...');
+    this.log.debug('Starting slasher client...');
 
     this.roundMonitor.start();
     await this.offensesCollector.start();
 
     // Listen for RoundExecuted events
     this.unwatchCallbacks.push(
-      this.tallySlashingProposer.listenToRoundExecuted(
+      this.slashingProposer.listenToRoundExecuted(
         ({ round, slashCount, l1BlockHash }) =>
           void this.handleRoundExecuted(round, slashCount, l1BlockHash).catch(err =>
             this.log.error('Error handling round executed', err),
@@ -120,24 +132,34 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     // Check for round changes
     this.unwatchCallbacks.push(this.roundMonitor.listenToNewRound(round => this.handleNewRound(round)));
 
-    this.log.info(`Started tally slasher client`);
+    // Warn early when a slashing vote names one of our own validators. Skipped entirely when running none, so
+    // those nodes pay no extra L1 subscription.
+    if (this.ownValidators.length > 0) {
+      this.ownValidatorMonitor.start(this.roundMonitor.getCurrentRound().round);
+      this.unwatchCallbacks.push(
+        this.slashingProposer.listenToVoteCast(
+          ({ round, voteIndex }) => void this.ownValidatorMonitor.handleVoteCast(round, voteIndex),
+        ),
+      );
+    }
+
+    this.log.info(`Started slasher client`);
     return Promise.resolve();
   }
 
-  /**
-   * Stop the tally slasher client
-   */
+  /** Stop the slasher client */
   public async stop() {
-    this.log.debug('Stopping Tally Slasher client...');
+    this.log.debug('Stopping slasher client...');
 
     for (const unwatchCallback of this.unwatchCallbacks) {
       unwatchCallback();
     }
 
     this.roundMonitor.stop();
+    await this.ownValidatorMonitor.stop();
     await this.offensesCollector.stop();
 
-    this.log.info('Tally Slasher client stopped');
+    this.log.info('Slasher client stopped');
   }
 
   /** Returns the current config */
@@ -152,14 +174,17 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
   /** Triggered on a time basis when we enter a new slashing round. Clears expired offenses. */
   protected async handleNewRound(round: bigint) {
-    this.log.info(`Starting new tally slashing round ${round}`);
+    this.log.info(`Starting new slashing round ${round}`);
+    this.ownValidatorMonitor.handleNewRound(round);
     await this.offensesCollector.handleNewRound(round);
   }
 
-  /** Called when we see a RoundExecuted event on the TallySlashingProposer (just for logging). */
+  /** Called when we see a RoundExecuted event on the SlashingProposer (just for logging and metrics). */
   protected async handleRoundExecuted(round: bigint, slashCount: bigint, l1BlockHash: Hex) {
+    this.metrics.recordRoundExecuted();
     const slashes = await this.rollup.getSlashEvents(l1BlockHash);
     this.log.info(`Slashing round ${round} has been executed with ${slashCount} slashes`, { slashes });
+    this.ownValidatorMonitor.handleSlashes(round, slashes, l1BlockHash);
   }
 
   /**
@@ -237,7 +262,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
 
     try {
-      const roundInfo = await this.tallySlashingProposer.getRound(executableRound);
+      const roundInfo = await this.slashingProposer.getRound(executableRound);
       logData = { ...logData, roundInfo };
       if (roundInfo.isExecuted) {
         this.log.verbose(`Round ${executableRound} has already been executed`, logData);
@@ -251,7 +276,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       }
 
       // Check if round is ready to execute at the given slot
-      const isReadyToExecute = await this.tallySlashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
+      const isReadyToExecute = await this.slashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
       if (!isReadyToExecute) {
         this.log.warn(
           `Round ${executableRound} is not ready to execute at slot ${slotNumber} according to contract check`,
@@ -261,14 +286,14 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       }
 
       // Check if the round yields any slashing at all
-      const { actions: slashActions, committees } = await this.tallySlashingProposer.getTally(executableRound);
+      const { actions: slashActions, committees } = await this.slashingProposer.getTally(executableRound);
       if (slashActions.length === 0) {
         this.log.verbose(`Round ${executableRound} does not resolve in any slashing`, logData);
         return undefined;
       }
 
       // Check if the slash payload is vetoed
-      const payload = await this.tallySlashingProposer.getPayload(executableRound);
+      const payload = await this.slashingProposer.getPayload(executableRound);
       const isVetoed = await this.slasher.isPayloadVetoed(payload.address);
       if (isVetoed) {
         this.log.warn(`Round ${executableRound} payload is vetoed (skipping execution)`, {
@@ -315,7 +340,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     // Compute offenses to slash, by loading the offenses for this round, adding synthetic offenses
     // for validators that should always be slashed, and removing the ones that should never be slashed.
     const offensesForRound = await this.gatherOffensesForRound(currentRound);
-    const offensesFromAlwaysSlash = (this.config.slashValidatorsAlways ?? []).map(validator => ({
+    const offensesFromAlwaysSlash: AlwaysSlashOffense[] = (this.config.slashValidatorsAlways ?? []).map(validator => ({
       validator,
       amount: this.settings.slashingAmounts[2],
       offenseType: OffenseType.UNKNOWN,
@@ -329,7 +354,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
         slotNumber,
         currentRound,
         slashedRound,
-        offensesToForgive,
+        offensesFromAlwaysSlash: offensesFromAlwaysSlash.map(getOffenseLogData),
         slashValidatorsAlways: this.config.slashValidatorsAlways,
       });
     }
@@ -339,7 +364,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
         slotNumber,
         currentRound,
         slashedRound,
-        offensesToForgive,
+        offensesToForgive: offensesToForgive.map(getOffenseLogData),
         slashValidatorsNever: this.config.slashValidatorsNever,
       });
     }
@@ -349,32 +374,42 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       return undefined;
     }
 
-    this.log.info(`Voting to slash ${offensesToSlash.length} offenses`, {
+    this.log.debug(`Computing slash votes for ${offensesToSlash.length} offenses`, {
       slotNumber,
       currentRound,
       slashedRound,
-      offensesToSlash,
+      offensesToSlash: offensesToSlash.map(getOffenseLogData),
     });
 
     const committees = await this.collectCommitteesActiveDuringRound(slashedRound);
     const epochsForCommittees = getEpochsForRound(slashedRound, this.settings);
+    const { slashMaxPayloadSize } = this.config;
     const votes = getSlashConsensusVotesFromOffenses(
       offensesToSlash,
       committees,
       epochsForCommittees.map(e => BigInt(e)),
-      this.settings,
+      { ...this.settings, maxSlashedValidators: slashMaxPayloadSize },
+      this.log,
     );
     if (votes.every(v => v === 0)) {
       this.log.warn(`Computed votes for offenses are all zero. Skipping vote.`, {
         slotNumber,
         currentRound,
         slashedRound,
-        offensesToSlash,
+        offensesToSlash: offensesToSlash.map(getOffenseLogData),
         committees,
       });
       return undefined;
     }
 
+    this.log.info(`Voting to slash ${offensesToSlash.length} offenses`, {
+      slotNumber,
+      slashedRound,
+      currentRound,
+      votes,
+      offensesToSlash: offensesToSlash.map(getOffenseLogData),
+    });
+
     this.log.debug(`Computed votes for slashing ${offensesToSlash.length} offenses`, {
       slashedRound,
       currentRound,
@@ -400,17 +435,9 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     );
   }
 
-  /**
-   * Get slash payloads is NOT SUPPORTED in tally model
-   * @throws Error indicating this operation is not supported
-   */
-  public getSlashPayloads(): Promise<SlashPayloadRound[]> {
-    return Promise.reject(new Error('Tally slashing model does not support slash payloads'));
-  }
-
   /**
    * Gather offenses to be slashed on a given round.
-   * In tally slashing, round N slashes validators from round N - slashOffsetInRounds.
+   * Round N slashes validators from round N - slashOffsetInRounds.
    * @param round - The round to get offenses for, defaults to current round
    * @returns Array of pending offenses for the round with offset applied
    */
@@ -423,9 +450,9 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     return await this.offensesStore.getOffensesForRound(targetRound);
   }
 
-  /** Returns all pending offenses stored */
-  public getPendingOffenses(): Promise<Offense[]> {
-    return this.offensesStore.getPendingOffenses();
+  /** Returns all offenses stored */
+  public getOffenses(): Promise<Offense[]> {
+    return this.offensesStore.getOffenses();
   }
 
   /**
@@ -441,3 +468,11 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     return round - BigInt(this.settings.slashingOffsetInRounds);
   }
 }
+
+function getOffenseLogData(offense: SlashVoteOffense) {
+  return {
+    ...offense,
+    validator: offense.validator.toString(),
+    offenseType: getOffenseTypeName(offense.offenseType),
+  };
+}

package/src/slasher_client_facade.ts

@@ -2,13 +2,13 @@ import { EpochCache } from '@aztec/epoch-cache';
 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 type { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { AztecLMDBStoreV2 } from '@aztec/kv-store/lmdb-v2';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
-import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
+import type { Offense, ProposerSlashAction } from '@aztec/stdlib/slashing';
 
 import { createSlasherImplementation } from './factory/create_implementation.js';
 import type { SlasherClientInterface } from './slasher_client_interface.js';
@@ -27,12 +27,12 @@ export class SlasherClientFacade implements SlasherClientInterface {
     private config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
     private rollup: RollupContract,
     private l1Client: ViemClient,
-    private slashFactoryAddress: EthAddress | undefined,
     private watchers: Watcher[],
     private epochCache: EpochCache,
     private dateProvider: DateProvider,
     private kvStore: AztecLMDBStoreV2,
     private rollupRegisteredAtL2Slot: SlotNumber,
+    private ownValidators: EthAddress[] = [],
     private logger = createLogger('slasher'),
   ) {}
 
@@ -63,16 +63,12 @@ export class SlasherClientFacade implements SlasherClientInterface {
     this.watchers.forEach(watcher => watcher.updateConfig?.(config));
   }
 
-  public getSlashPayloads(): Promise<SlashPayloadRound[]> {
-    return this.client?.getSlashPayloads() ?? Promise.reject(new Error('Slasher client not initialized'));
-  }
-
   public gatherOffensesForRound(round?: bigint): Promise<Offense[]> {
     return this.client?.gatherOffensesForRound(round) ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 
-  public getPendingOffenses(): Promise<Offense[]> {
-    return this.client?.getPendingOffenses() ?? Promise.reject(new Error('Slasher client not initialized'));
+  public getOffenses(): Promise<Offense[]> {
+    return this.client?.getOffenses() ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 
   public getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
@@ -84,12 +80,12 @@ export class SlasherClientFacade implements SlasherClientInterface {
       this.config,
       this.rollup,
       this.l1Client,
-      this.slashFactoryAddress,
       this.watchers,
       this.epochCache,
       this.dateProvider,
       this.kvStore,
       this.rollupRegisteredAtL2Slot,
+      this.ownValidators,
       this.logger,
     );
   }

package/src/slasher_client_interface.ts

@@ -1,11 +1,8 @@
 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';
+import type { Offense, ProposerSlashAction } from '@aztec/stdlib/slashing';
 
-/**
- * Common interface for slasher clients used by the Aztec node.
- * Both Empire and Consensus slasher clients implement this interface.
- */
+/** Common interface for slasher clients used by the Aztec node. */
 export interface SlasherClientInterface {
   /** Start the slasher client */
   start(): Promise<void>;
@@ -13,25 +10,13 @@ export interface SlasherClientInterface {
   /** Stop the slasher client */
   stop(): Promise<void>;
 
-  /**
-   * Get slash payloads for the Empire model.
-   * The Consensus model should throw an error when this is called.
-   */
-  getSlashPayloads(): Promise<SlashPayloadRound[]>;
-
-  /**
-   * Gather offenses for a given round, defaults to current.
-   * Used by both Empire and Consensus models.
-   */
+  /** Gather offenses for a given round, defaults to current. */
   gatherOffensesForRound(round?: bigint): Promise<Offense[]>;
 
-  /** Returns all pending offenses */
-  getPendingOffenses(): Promise<Offense[]>;
+  /** Returns all offenses */
+  getOffenses(): Promise<Offense[]>;
 
-  /**
-   * Update the configuration.
-   * Used by both Empire and Consensus models.
-   */
+  /** Update the configuration. */
   updateConfig(config: Partial<SlasherConfig>): void;
 
   /**

package/src/stores/offenses_store.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/aztec.js/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSet } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import {
   type Offense,
   type OffenseIdentifier,
@@ -10,14 +10,15 @@ import {
 
 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>;
 
-  /** Map from offense key to whether the offense has been executed (only used for empire based slashing) */
-  private offensesSlashed: AztecAsyncSet<string>;
-
-  /** Multimap from round to offense keys (only used for consensus based slashing) */
+  /** Multimap from round to offense keys */
   private roundsOffenses: AztecAsyncMultiMap<string, string>;
 
   private log = createLogger('slasher:store:offenses');
@@ -32,18 +33,13 @@ export class SlasherOffensesStore {
   ) {
     this.offenses = kvStore.openMap('offenses');
     this.roundsOffenses = kvStore.openMultiMap('rounds-offenses');
-    this.offensesSlashed = kvStore.openSet('offenses-slashed');
   }
 
-  /** Returns all offenses not marked as slashed */
-  public async getPendingOffenses(): Promise<Offense[]> {
+  /** Returns all offenses */
+  public async getOffenses(): Promise<Offense[]> {
     const offenses: Offense[] = [];
-    for await (const [key, buffer] of this.offenses.entriesAsync()) {
-      if (await this.offensesSlashed.hasAsync(key)) {
-        continue; // Skip executed offenses
-      }
-      const offense = deserializeOffense(buffer);
-      offenses.push(offense);
+    for await (const [, buffer] of this.offenses.entriesAsync()) {
+      offenses.push(deserializeOffense(buffer));
     }
     return offenses;
   }
@@ -61,36 +57,68 @@ export class SlasherOffensesStore {
     return offenses;
   }
 
-  /** Returns whether an offense is pending (ie not marked as slashed) */
-  public async hasPendingOffense(offense: OffenseIdentifier): Promise<boolean> {
-    const key = this.getOffenseKey(offense);
-    return (await this.offenses.getAsync(key)) !== undefined && !(await this.offensesSlashed.hasAsync(key));
-  }
-
   /** 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 (defaults to pending, but will be slashed if markAsSlashed had been called for it) */
-  public async addPendingOffense(offense: Offense): Promise<void> {
+  /** 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);
-    await this.kvStore.transactionAsync(async () => {
+    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;
     });
-    this.log.trace(`Adding pending offense ${key} for round ${round}`);
+
+    if (added) {
+      this.log.trace(`Adding pending offense ${key} for round ${round}`);
+    }
+
+    return added;
   }
 
-  /** Marks the given offenses as slashed (regardless of whether they are known or not)  */
-  public async markAsSlashed(offenses: OffenseIdentifier[]): Promise<void> {
-    await this.kvStore.transactionAsync(async () => {
-      for (const offense of offenses) {
-        const key = this.getOffenseKey(offense);
-        await this.offensesSlashed.add(key);
+  /** 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;
     });
   }
 
@@ -106,34 +134,32 @@ export class SlasherOffensesStore {
       return 0; // Not enough rounds have passed to expire anything
     }
 
-    // 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);
-    }
+    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
-    }
+      if (expiredOffenseKeys.size === 0 && expiredRoundKeys.size === 0) {
+        return 0; // Nothing to clean up
+      }
 
-    // Remove expired stuff in a transaction
-    await this.kvStore.transactionAsync(async () => {
       for (const key of expiredOffenseKeys) {
         this.log.trace(`Deleting offense ${key}`);
         await this.offenses.delete(key);
-        await this.offensesSlashed.delete(key);
       }
       for (const roundKey of expiredRoundKeys) {
         this.log.trace(`Deleting round info for ${roundKey}`);
         await this.roundsOffenses.delete(roundKey);
       }
-    });
 
-    return expiredOffenseKeys.size;
+      return expiredOffenseKeys.size;
+    });
   }
 
   /** Generate a unique key for an offense */

package/src/watcher.ts

@@ -5,6 +5,7 @@ import { OffenseType } from '@aztec/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;
@@ -13,9 +14,16 @@ export interface WantToSlashArgs {
   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>;