@aztec/slasher 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/config.ts

@@ -14,20 +14,24 @@ export type { SlasherConfig };
 
 export const DefaultSlasherConfig: SlasherConfig = {
   slashOverridePayload: undefined,
-  slashMinPenaltyPercentage: slasherDefaultEnv.SLASH_MIN_PENALTY_PERCENTAGE,
-  slashMaxPenaltyPercentage: slasherDefaultEnv.SLASH_MAX_PENALTY_PERCENTAGE,
   slashValidatorsAlways: [], // Empty by default
   slashValidatorsNever: [], // Empty by default
-  slashPrunePenalty: BigInt(slasherDefaultEnv.SLASH_PRUNE_PENALTY),
   slashDataWithholdingPenalty: BigInt(slasherDefaultEnv.SLASH_DATA_WITHHOLDING_PENALTY),
+  slashDataWithholdingToleranceSlots: slasherDefaultEnv.SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS,
   slashInactivityTargetPercentage: slasherDefaultEnv.SLASH_INACTIVITY_TARGET_PERCENTAGE,
   slashInactivityConsecutiveEpochThreshold: slasherDefaultEnv.SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD,
   slashBroadcastedInvalidBlockPenalty: BigInt(slasherDefaultEnv.SLASH_INVALID_BLOCK_PENALTY),
+  slashBroadcastedInvalidCheckpointProposalPenalty: BigInt(slasherDefaultEnv.SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY),
   slashDuplicateProposalPenalty: BigInt(slasherDefaultEnv.SLASH_DUPLICATE_PROPOSAL_PENALTY),
   slashDuplicateAttestationPenalty: BigInt(slasherDefaultEnv.SLASH_DUPLICATE_ATTESTATION_PENALTY),
   slashInactivityPenalty: BigInt(slasherDefaultEnv.SLASH_INACTIVITY_PENALTY),
   slashProposeInvalidAttestationsPenalty: BigInt(slasherDefaultEnv.SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY),
-  slashAttestDescendantOfInvalidPenalty: BigInt(slasherDefaultEnv.SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY),
+  slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty: BigInt(
+    slasherDefaultEnv.SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY,
+  ),
+  slashAttestInvalidCheckpointProposalPenalty: BigInt(
+    slasherDefaultEnv.SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY,
+  ),
   slashUnknownPenalty: BigInt(slasherDefaultEnv.SLASH_UNKNOWN_PENALTY),
   slashOffenseExpirationRounds: slasherDefaultEnv.SLASH_OFFENSE_EXPIRATION_ROUNDS,
   slashMaxPayloadSize: slasherDefaultEnv.SLASH_MAX_PAYLOAD_SIZE,
@@ -40,19 +44,9 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
   slashOverridePayload: {
     env: 'SLASH_OVERRIDE_PAYLOAD',
     description: 'An Ethereum address for a slash payload to vote for unconditionally.',
-    parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),
+    parseEnv: (val: string) => EthAddress.fromString(val),
     defaultValue: DefaultSlasherConfig.slashOverridePayload,
   },
-  slashMinPenaltyPercentage: {
-    env: 'SLASH_MIN_PENALTY_PERCENTAGE',
-    description: 'Minimum penalty percentage for slashing offenses (0.1 is 10%).',
-    ...floatConfigHelper(DefaultSlasherConfig.slashMinPenaltyPercentage),
-  },
-  slashMaxPenaltyPercentage: {
-    env: 'SLASH_MAX_PENALTY_PERCENTAGE',
-    description: 'Maximum penalty percentage for slashing offenses (2.0 is 200%).',
-    ...floatConfigHelper(DefaultSlasherConfig.slashMaxPenaltyPercentage),
-  },
   slashValidatorsAlways: {
     env: 'SLASH_VALIDATORS_ALWAYS',
     description: 'Comma-separated list of validator addresses that should always be slashed.',
@@ -75,21 +69,27 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
         .map(addr => EthAddress.fromString(addr)),
     defaultValue: DefaultSlasherConfig.slashValidatorsNever,
   },
-  slashPrunePenalty: {
-    env: 'SLASH_PRUNE_PENALTY',
-    description: 'Penalty amount for slashing validators of a valid pruned epoch (set to 0 to disable).',
-    ...bigintConfigHelper(DefaultSlasherConfig.slashPrunePenalty),
-  },
   slashDataWithholdingPenalty: {
     env: 'SLASH_DATA_WITHHOLDING_PENALTY',
-    description: 'Penalty amount for slashing validators for data withholding (set to 0 to disable).',
+    description: 'Penalty for data withholding (0 records offenses without slash votes).',
     ...bigintConfigHelper(DefaultSlasherConfig.slashDataWithholdingPenalty),
   },
+  slashDataWithholdingToleranceSlots: {
+    env: 'SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS',
+    description:
+      'Number of full L2 slots that must elapse after a checkpoint slot before declaring its txs missing and slashing its attesters for data withholding.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashDataWithholdingToleranceSlots),
+  },
   slashBroadcastedInvalidBlockPenalty: {
     env: 'SLASH_INVALID_BLOCK_PENALTY',
     description: 'Penalty amount for slashing a validator for an invalid block proposed via p2p.',
     ...bigintConfigHelper(DefaultSlasherConfig.slashBroadcastedInvalidBlockPenalty),
   },
+  slashBroadcastedInvalidCheckpointProposalPenalty: {
+    env: 'SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+    description: 'Penalty amount for slashing a validator for an invalid checkpoint proposal proposed via p2p.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashBroadcastedInvalidCheckpointProposalPenalty),
+  },
   slashDuplicateProposalPenalty: {
     env: 'SLASH_DUPLICATE_PROPOSAL_PENALTY',
     description: 'Penalty amount for slashing a validator for sending duplicate proposals.',
@@ -125,23 +125,28 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
   },
   slashInactivityPenalty: {
     env: 'SLASH_INACTIVITY_PENALTY',
-    description: 'Penalty amount for slashing an inactive validator (set to 0 to disable).',
+    description: 'Penalty for an inactive validator (0 records offenses without slash votes).',
     ...bigintConfigHelper(DefaultSlasherConfig.slashInactivityPenalty),
   },
   slashProposeInvalidAttestationsPenalty: {
     env: 'SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY',
-    description: 'Penalty amount for slashing a proposer that proposed invalid attestations (set to 0 to disable).',
+    description: 'Penalty for proposing invalid attestations (0 records offenses without slash votes).',
     ...bigintConfigHelper(DefaultSlasherConfig.slashProposeInvalidAttestationsPenalty),
   },
-  slashAttestDescendantOfInvalidPenalty: {
-    env: 'SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY',
+  slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty: {
+    env: 'SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY',
     description:
-      'Penalty amount for slashing a validator that attested to a descendant of an invalid block (set to 0 to disable).',
-    ...bigintConfigHelper(DefaultSlasherConfig.slashAttestDescendantOfInvalidPenalty),
+      'Penalty for publishing a checkpoint building on an invalid checkpoint (0 records offenses without slash votes).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty),
+  },
+  slashAttestInvalidCheckpointProposalPenalty: {
+    env: 'SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY',
+    description: 'Penalty for attesting to an invalid checkpoint proposal (0 records offenses without slash votes).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashAttestInvalidCheckpointProposalPenalty),
   },
   slashUnknownPenalty: {
     env: 'SLASH_UNKNOWN_PENALTY',
-    description: 'Penalty amount for slashing a validator for an unknown offense (set to 0 to disable).',
+    description: 'Penalty for an unknown offense (0 records offenses without slash votes).',
     ...bigintConfigHelper(DefaultSlasherConfig.slashUnknownPenalty),
   },
   slashOffenseExpirationRounds: {

package/src/factory/create_facade.ts

@@ -20,7 +20,7 @@ import type { Watcher } from '../watcher.js';
 /** Creates a slasher client facade that updates itself whenever the rollup slasher changes */
 export async function createSlasherFacade(
   config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
-  l1Contracts: Pick<L1ReaderConfig['l1Contracts'], 'rollupAddress' | 'slashFactoryAddress' | 'registryAddress'>,
+  l1Contracts: Pick<L1ReaderConfig, 'rollupAddress' | 'registryAddress'>,
   l1Client: ViemClient,
   watchers: Watcher[],
   dateProvider: DateProvider,
@@ -71,7 +71,6 @@ export async function createSlasherFacade(
     updatedConfig,
     rollup,
     l1Client,
-    l1Contracts.slashFactoryAddress,
     watchers,
     epochCache,
     dateProvider,

package/src/factory/create_implementation.ts

@@ -1,33 +1,24 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  EmpireSlashingProposerContract,
-  RollupContract,
-  TallySlashingProposerContract,
-} from '@aztec/ethereum/contracts';
+import { RollupContract, SlashingProposerContract } 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';
 import { AztecLMDBStoreV2 } from '@aztec/kv-store/lmdb-v2';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
-import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 
-import { EmpireSlasherClient, type EmpireSlasherSettings } from '../empire_slasher_client.js';
 import { NullSlasherClient } from '../null_slasher_client.js';
+import { SlasherClient } from '../slasher_client.js';
 import { SlasherOffensesStore } from '../stores/offenses_store.js';
-import { SlasherPayloadsStore } from '../stores/payloads_store.js';
-import { TallySlasherClient } from '../tally_slasher_client.js';
 import type { Watcher } from '../watcher.js';
-import { getTallySlasherSettings } from './get_settings.js';
+import { getSlasherSettings } from './get_settings.js';
 
-/** Creates a slasher client implementation (either tally or empire) based on the slasher proposer type in the rollup */
+/** Creates a slasher client implementation based on the slasher proposer type in the rollup */
 export async function createSlasherImplementation(
   config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
   rollup: RollupContract,
   l1Client: ViemClient,
-  slashFactoryAddress: EthAddress | undefined,
   watchers: Watcher[],
   epochCache: EpochCache,
   dateProvider: DateProvider,
@@ -38,30 +29,14 @@ export async function createSlasherImplementation(
   const proposer = await rollup.getSlashingProposer();
   if (!proposer) {
     return new NullSlasherClient(config);
-  } else if (proposer.type === 'tally') {
-    return createTallySlasher(
-      config,
-      rollup,
-      proposer,
-      watchers,
-      dateProvider,
-      epochCache,
-      kvStore,
-      rollupRegisteredAtL2Slot,
-      logger,
-    );
   } else {
-    if (!slashFactoryAddress || slashFactoryAddress.equals(EthAddress.ZERO)) {
-      throw new Error('Cannot initialize an empire-based SlasherClient without a SlashFactory address');
-    }
-    const slashFactory = new SlashFactoryContract(l1Client, slashFactoryAddress.toString());
-    return createEmpireSlasher(
+    return createSlasher(
       config,
       rollup,
       proposer,
-      slashFactory,
       watchers,
       dateProvider,
+      epochCache,
       kvStore,
       rollupRegisteredAtL2Slot,
       logger,
@@ -69,99 +44,18 @@ export async function createSlasherImplementation(
   }
 }
 
-async function createEmpireSlasher(
-  config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
-  rollup: RollupContract,
-  slashingProposer: EmpireSlashingProposerContract,
-  slashFactoryContract: SlashFactoryContract,
-  watchers: Watcher[],
-  dateProvider: DateProvider,
-  kvStore: AztecLMDBStoreV2,
-  rollupRegisteredAtL2Slot: SlotNumber,
-  logger = createLogger('slasher'),
-): Promise<EmpireSlasherClient> {
-  if (slashingProposer.type !== 'empire') {
-    throw new Error('Slashing proposer contract is not of type Empire');
-  }
-
-  const [
-    slashingExecutionDelayInRounds,
-    slashingPayloadLifetimeInRounds,
-    slashingRoundSize,
-    slashingQuorumSize,
-    epochDuration,
-    proofSubmissionEpochs,
-    l1GenesisTime,
-    slotDuration,
-    l1StartBlock,
-    slasher,
-  ] = await Promise.all([
-    slashingProposer.getExecutionDelayInRounds(),
-    slashingProposer.getLifetimeInRounds(),
-    slashingProposer.getRoundSize(),
-    slashingProposer.getQuorumSize(),
-    rollup.getEpochDuration(),
-    rollup.getProofSubmissionEpochs(),
-    rollup.getL1GenesisTime(),
-    rollup.getSlotDuration(),
-    rollup.getL1StartBlock(),
-    rollup.getSlasherContract(),
-  ]);
-
-  const settings: EmpireSlasherSettings = {
-    slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
-    slashingPayloadLifetimeInRounds: Number(slashingPayloadLifetimeInRounds),
-    slashingRoundSize: Number(slashingRoundSize),
-    slashingQuorumSize: Number(slashingQuorumSize),
-    epochDuration: Number(epochDuration),
-    proofSubmissionEpochs: Number(proofSubmissionEpochs),
-    l1GenesisTime: l1GenesisTime,
-    slotDuration: Number(slotDuration),
-    l1StartBlock,
-    ethereumSlotDuration: config.ethereumSlotDuration,
-    slashingAmounts: undefined,
-    rollupRegisteredAtL2Slot,
-  };
-
-  const payloadsStore = new SlasherPayloadsStore(kvStore, {
-    slashingPayloadLifetimeInRounds: settings.slashingPayloadLifetimeInRounds,
-  });
-  const offensesStore = new SlasherOffensesStore(kvStore, {
-    ...settings,
-    slashOffenseExpirationRounds: config.slashOffenseExpirationRounds,
-  });
-
-  return new EmpireSlasherClient(
-    config,
-    settings,
-    slashFactoryContract,
-    slashingProposer,
-    slasher!,
-    rollup,
-    watchers,
-    dateProvider,
-    offensesStore,
-    payloadsStore,
-    logger,
-  );
-}
-
-async function createTallySlasher(
+async function createSlasher(
   config: SlasherConfig & DataStoreConfig,
   rollup: RollupContract,
-  slashingProposer: TallySlashingProposerContract,
+  slashingProposer: SlashingProposerContract,
   watchers: Watcher[],
   dateProvider: DateProvider,
   epochCache: EpochCache,
   kvStore: AztecLMDBStoreV2,
   rollupRegisteredAtL2Slot: SlotNumber,
   logger = createLogger('slasher'),
-): Promise<TallySlasherClient> {
-  if (slashingProposer.type !== 'tally') {
-    throw new Error('Slashing proposer contract is not of type tally');
-  }
-
-  const settings = { ...(await getTallySlasherSettings(rollup, slashingProposer)), rollupRegisteredAtL2Slot };
+): Promise<SlasherClient> {
+  const settings = { ...(await getSlasherSettings(rollup, slashingProposer)), rollupRegisteredAtL2Slot };
   const slasher = await rollup.getSlasherContract();
 
   const offensesStore = new SlasherOffensesStore(kvStore, {
@@ -169,7 +63,7 @@ async function createTallySlasher(
     slashOffenseExpirationRounds: config.slashOffenseExpirationRounds,
   });
 
-  return new TallySlasherClient(
+  return new SlasherClient(
     config,
     settings,
     slashingProposer,

package/src/factory/get_settings.ts

@@ -1,15 +1,15 @@
-import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import type { RollupContract, SlashingProposerContract } from '@aztec/ethereum/contracts';
 
-import type { TallySlasherSettings } from '../tally_slasher_client.js';
+import type { SlasherSettings } from '../slasher_client.js';
 
-export async function getTallySlasherSettings(
+export async function getSlasherSettings(
   rollup: RollupContract,
-  slashingProposer?: TallySlashingProposerContract,
-): Promise<Omit<TallySlasherSettings, 'rollupRegisteredAtL2Slot'>> {
+  slashingProposer?: SlashingProposerContract,
+): Promise<Omit<SlasherSettings, 'rollupRegisteredAtL2Slot'>> {
   if (!slashingProposer) {
     const rollupSlashingProposer = await rollup.getSlashingProposer();
-    if (!rollupSlashingProposer || rollupSlashingProposer.type !== 'tally') {
-      throw new Error('Rollup slashing proposer is not of type tally');
+    if (!rollupSlashingProposer) {
+      throw new Error('Rollup slashing proposer not found');
     }
     slashingProposer = rollupSlashingProposer;
   }
@@ -40,7 +40,7 @@ export async function getTallySlasherSettings(
     rollup.getTargetCommitteeSize(),
   ]);
 
-  const settings: Omit<TallySlasherSettings, 'rollupRegisteredAtL2Slot'> = {
+  const settings: Omit<SlasherSettings, 'rollupRegisteredAtL2Slot'> = {
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
     slashingRoundSize: Number(slashingRoundSize),
     slashingRoundSizeInEpochs: Number(slashingRoundSizeInEpochs),

package/src/factory/index.ts

@@ -1,2 +1,2 @@
 export { createSlasherFacade as createSlasher } from './create_facade.js';
-export { getTallySlasherSettings } from './get_settings.js';
+export { getSlasherSettings } from './get_settings.js';

package/src/generated/slasher-defaults.ts

@@ -3,21 +3,21 @@
 
 /** 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: 80,
   SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
-  SLASH_PRUNE_PENALTY: 10000000000000000000,
   SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
   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_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 10000000000000000000,
   SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
   SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
   SLASH_UNKNOWN_PENALTY: 10000000000000000000,
   SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
   SLASH_GRACE_PERIOD_L2_SLOTS: 0,
 } as const;

package/src/index.ts

@@ -1,8 +1,10 @@
 export * from './config.js';
-export * from './watchers/epoch_prune_watcher.js';
+export * from './watchers/data_withholding_watcher.js';
 export * from './watchers/attestations_block_watcher.js';
-export * from './empire_slasher_client.js';
-export * from './tally_slasher_client.js';
+export * from './watchers/attested_invalid_proposal_watcher.js';
+export * from './watchers/broadcasted_invalid_checkpoint_proposal_watcher.js';
+export * from './watchers/checkpoint_equivocation_watcher.js';
+export * from './slasher_client.js';
 export * from './slash_offenses_collector.js';
 export * from './slasher_client_interface.js';
 export * from './factory/index.js';

package/src/metrics.ts

@@ -0,0 +1,19 @@
+import {
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} from '@aztec/telemetry-client';
+
+export class SlasherMetrics {
+  private readonly roundExecuted: UpDownCounter;
+
+  constructor(client: TelemetryClient, name = 'Slasher') {
+    const meter = client.getMeter(name);
+    this.roundExecuted = createUpDownCounterWithDefault(meter, Metrics.SLASHER_ROUND_EXECUTED_COUNT);
+  }
+
+  public recordRoundExecuted(): void {
+    this.roundExecuted.add(1);
+  }
+}

package/src/null_slasher_client.ts

@@ -1,5 +1,5 @@
 import type { SlotNumber } from '@aztec/foundation/branded-types';
-import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
+import type { Offense, ProposerSlashAction } from '@aztec/stdlib/slashing';
 
 import type { SlasherConfig } from './config.js';
 import type { SlasherClientInterface } from './slasher_client_interface.js';
@@ -15,15 +15,11 @@ export class NullSlasherClient implements SlasherClientInterface {
     return Promise.resolve();
   }
 
-  public getSlashPayloads(): Promise<SlashPayloadRound[]> {
-    return Promise.resolve([]);
-  }
-
   public gatherOffensesForRound(_round?: bigint): Promise<Offense[]> {
     return Promise.resolve([]);
   }
 
-  public getPendingOffenses(): Promise<Offense[]> {
+  public getOffenses(): Promise<Offense[]> {
     return Promise.resolve([]);
   }
 

package/src/slash_offenses_collector.ts

@@ -1,12 +1,19 @@
 import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
 import type { Prettify } from '@aztec/foundation/types';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
-import { type Offense, type OffenseIdentifier, getSlotForOffense } from '@aztec/stdlib/slashing';
+import { type Offense, getOffenseTypeName, getSlotForOffense } from '@aztec/stdlib/slashing';
 
 import type { SlasherOffensesStore } from './stores/offenses_store.js';
-import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher } from './watcher.js';
+import {
+  WANT_TO_CLEAR_SLASH_EVENT,
+  WANT_TO_SLASH_EVENT,
+  type WantToClearSlashArgs,
+  type WantToSlashArgs,
+  type Watcher,
+} from './watcher.js';
 
 export type SlashOffensesCollectorConfig = Prettify<Pick<SlasherConfig, 'slashGracePeriodL2Slots'>>;
 export type SlashOffensesCollectorSettings = Prettify<
@@ -24,6 +31,7 @@ export type SlashOffensesCollectorSettings = Prettify<
  */
 export class SlashOffensesCollector {
   private readonly unwatchCallbacks: (() => void)[] = [];
+  private readonly storeMutationQueue = new SerialQueue();
 
   constructor(
     private readonly config: SlashOffensesCollectorConfig,
@@ -35,28 +43,35 @@ export class SlashOffensesCollector {
 
   public start() {
     this.log.debug('Starting SlashOffensesCollector...');
+    this.storeMutationQueue.start();
 
-    // Subscribe to watchers WANT_TO_SLASH_EVENT
+    // Subscribe to watcher slashing events.
     for (const watcher of this.watchers) {
       const wantToSlashCallback = (args: WantToSlashArgs[]) =>
-        void this.handleWantToSlash(args).catch(err => this.log.error('Error handling wantToSlash', err));
+        this.enqueueStoreMutation('wantToSlash', () => this.handleWantToSlash(args));
       watcher.on(WANT_TO_SLASH_EVENT, wantToSlashCallback);
       this.unwatchCallbacks.push(() => watcher.removeListener(WANT_TO_SLASH_EVENT, wantToSlashCallback));
+
+      const wantToClearSlashCallback = (args: WantToClearSlashArgs[]) =>
+        this.enqueueStoreMutation('wantToClearSlash', () => this.handleWantToClearSlash(args));
+      watcher.on(WANT_TO_CLEAR_SLASH_EVENT, wantToClearSlashCallback);
+      this.unwatchCallbacks.push(() => watcher.removeListener(WANT_TO_CLEAR_SLASH_EVENT, wantToClearSlashCallback));
     }
 
     this.log.info('Started SlashOffensesCollector');
     return Promise.resolve();
   }
 
-  public stop() {
+  public async stop() {
     this.log.debug('Stopping SlashOffensesCollector...');
 
     for (const unwatchCallback of this.unwatchCallbacks) {
       unwatchCallback();
     }
 
+    await this.storeMutationQueue.end();
+
     this.log.info('SlashOffensesCollector stopped');
-    return Promise.resolve();
   }
 
   /**
@@ -66,32 +81,47 @@ export class SlashOffensesCollector {
    */
   public async handleWantToSlash(args: WantToSlashArgs[]) {
     for (const arg of args) {
-      const pendingOffense: Offense = {
+      const offense: Offense = {
         validator: arg.validator,
         amount: arg.amount,
         offenseType: arg.offenseType,
         epochOrSlot: arg.epochOrSlot,
       };
 
-      if (this.shouldSkipOffense(pendingOffense)) {
-        this.log.verbose('Skipping offense during grace period', pendingOffense);
-        continue;
-      }
-
-      if (await this.offensesStore.hasOffense(pendingOffense)) {
-        this.log.debug('Skipping repeated offense', pendingOffense);
+      if (this.shouldSkipOffense(offense)) {
+        this.log.verbose('Skipping offense during grace period', this.getOffenseLogData(offense));
         continue;
       }
 
-      if (this.settings.slashingAmounts) {
-        const minSlash = this.settings.slashingAmounts[0];
-        if (arg.amount < minSlash) {
-          this.log.warn(`Offense amount ${arg.amount} is below minimum slashing amount ${minSlash}`);
+      const added = await this.offensesStore.addOffense(offense);
+      if (added) {
+        if (this.settings.slashingAmounts) {
+          const minSlash = this.settings.slashingAmounts[0];
+          if (arg.amount < minSlash) {
+            this.log.warn(
+              `Offense amount ${arg.amount} is below minimum slashing amount ${minSlash}`,
+              this.getOffenseLogData(offense),
+            );
+          }
         }
+
+        this.log.info(`Adding pending offense for validator ${arg.validator}`, this.getOffenseLogData(offense));
+      } else {
+        this.log.debug('Skipping repeated offense', this.getOffenseLogData(offense));
       }
+    }
+  }
 
-      this.log.info(`Adding pending offense for validator ${arg.validator}`, pendingOffense);
-      await this.offensesStore.addPendingOffense(pendingOffense);
+  public async handleWantToClearSlash(args: WantToClearSlashArgs[]) {
+    for (const arg of args) {
+      const cleared = await this.offensesStore.clearOffenses(arg);
+      if (cleared > 0) {
+        this.log.info(`Cleared ${cleared} pending offenses`, {
+          offenseType: getOffenseTypeName(arg.offenseType),
+          epochOrSlot: arg.epochOrSlot,
+          validators: arg.validators?.map(validator => validator.toString()),
+        });
+      }
     }
   }
 
@@ -106,18 +136,21 @@ export class SlashOffensesCollector {
     }
   }
 
-  /**
-   * Marks offenses as slashed (no longer pending)
-   * @param offenses - The offenses to mark as slashed
-   */
-  public markAsSlashed(offenses: OffenseIdentifier[]) {
-    this.log.verbose(`Marking offenses as slashed`, { offenses });
-    return this.offensesStore.markAsSlashed(offenses);
-  }
-
   /** Returns whether to skip an offense if it happened during the grace period after the network upgrade */
   private shouldSkipOffense(offense: Offense): boolean {
     const offenseSlot = getSlotForOffense(offense, this.settings);
     return offenseSlot < this.settings.rollupRegisteredAtL2Slot + this.config.slashGracePeriodL2Slots;
   }
+
+  private getOffenseLogData(offense: Offense) {
+    return {
+      ...offense,
+      validator: offense.validator.toString(),
+      offenseType: getOffenseTypeName(offense.offenseType),
+    };
+  }
+
+  private enqueueStoreMutation(label: string, callback: () => Promise<void>) {
+    void this.storeMutationQueue.put(callback).catch(err => this.log.error(`Error handling ${label}`, err));
+  }
 }