@aztec/slasher 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/dest/watchers/data_withholding_watcher.js

@@ -0,0 +1,193 @@
+import { CheckpointProposalHash, SlotNumber } from '@aztec/foundation/branded-types';
+import { compactArray, merge, pick } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+import { getAttestationInfoFromPublishedCheckpoint } from '@aztec/stdlib/block';
+import { ConsensusPayload } from '@aztec/stdlib/p2p';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
+import EventEmitter from 'node:events';
+import { WANT_TO_SLASH_EVENT } from '../watcher.js';
+const DataWithholdingWatcherConfigKeys = [
+    'slashDataWithholdingPenalty',
+    'slashDataWithholdingToleranceSlots'
+];
+/**
+ * Detects data-withholding offenses by probing the local mempool for the txs in published
+ * checkpoints once they are old enough that an honest node should have collected them.
+ *
+ * Per AZIP-7: once `slashDataWithholdingToleranceSlots` full slots have elapsed after the
+ * checkpoint's slot — i.e. at `slotStart(checkpoint.slot + slashDataWithholdingToleranceSlots
+ * + 1)` — if any tx from the checkpoint's blocks is still missing locally, the checkpoint's
+ * attesters are considered at fault for not making the data available, and we emit a slash
+ * for them.
+ *
+ * The watcher ticks at quarter-eth-slot cadence (matching the Sentinel template). On boot it
+ * floors processing at the current slot — restart-time gaps are accepted and not back-filled,
+ * matching the Sentinel approach.
+ */ export class DataWithholdingWatcher extends EventEmitter {
+    epochCache;
+    l2BlockSource;
+    txProvider;
+    p2p;
+    reexecutionTracker;
+    signatureContext;
+    log;
+    runningPromise;
+    initialSlot;
+    lastCheckedSlot;
+    config;
+    constructor(epochCache, l2BlockSource, txProvider, p2p, reexecutionTracker, signatureContext, config, log = createLogger('data-withholding-watcher')){
+        super(), this.epochCache = epochCache, this.l2BlockSource = l2BlockSource, this.txProvider = txProvider, this.p2p = p2p, this.reexecutionTracker = reexecutionTracker, this.signatureContext = signatureContext, this.log = log;
+        this.config = pick(config, ...DataWithholdingWatcherConfigKeys);
+        const interval = epochCache.getL1Constants().ethereumSlotDuration * 1000 / 4;
+        this.runningPromise = new RunningPromise(this.work.bind(this), log, interval);
+        this.log.verbose(`DataWithholdingWatcher initialized`, this.config);
+    }
+    async start() {
+        // Floor processing at the archiver's synced slot rather than the wallclock — restart-time
+        // gaps before the archiver catches up are accepted and not back-filled. Falls back to the
+        // wallclock if the archiver isn't ready yet (cold start).
+        const syncedSlot = await this.l2BlockSource.getSyncedL2SlotNumber();
+        this.initialSlot = syncedSlot ?? this.epochCache.getSlotNow();
+        this.log.info(`Starting data-withholding watcher with initial slot ${this.initialSlot}`);
+        this.runningPromise.start();
+    }
+    stop() {
+        return this.runningPromise.stop();
+    }
+    updateConfig(config) {
+        this.config = merge(this.config, pick(config, ...DataWithholdingWatcherConfigKeys));
+        this.log.verbose('DataWithholdingWatcher config updated', this.config);
+    }
+    /**
+   * Runs every tick. Walks newly-eligible slots and probes their checkpoints for data
+   * availability; emits a DATA_WITHHOLDING slash for any checkpoint whose txs are missing.
+   */ async work() {
+        if (this.initialSlot === undefined) {
+            return;
+        }
+        // tolerance is the number of full slots that must elapse after the checkpoint's slot
+        // before we declare its data missing. For checkpoint slot S, we therefore process S
+        // only once we are in slot `S + tolerance + 1` or later. Drive this off the archiver's
+        // synced slot rather than the wallclock so we don't make claims about slots we haven't
+        // fully ingested yet (archiver may lag behind L1).
+        const tolerance = this.config.slashDataWithholdingToleranceSlots;
+        const currentSlot = await this.l2BlockSource.getSyncedL2SlotNumber() ?? this.epochCache.getSlotNow();
+        if (currentSlot <= tolerance) {
+            return;
+        }
+        const targetSlot = SlotNumber(currentSlot - tolerance - 1);
+        if (targetSlot <= this.initialSlot) {
+            return;
+        }
+        const startSlot = this.lastCheckedSlot === undefined ? this.initialSlot : this.lastCheckedSlot;
+        for(let slot = SlotNumber(startSlot + 1); slot <= targetSlot; slot = SlotNumber(slot + 1)){
+            try {
+                await this.processSlot(slot);
+            } catch (err) {
+                this.log.error(`Error processing slot ${slot} for data-withholding check`, err, {
+                    slot
+                });
+            }
+            this.lastCheckedSlot = slot;
+        }
+    }
+    /** Probes the checkpoint at the given slot, if any, and emits a slash on missing txs. */ async processSlot(slot) {
+        const published = await this.l2BlockSource.getCheckpoint({
+            slot
+        });
+        if (!published) {
+            this.log.trace(`No published checkpoint at slot ${slot}`, {
+                slot
+            });
+            return;
+        }
+        const checkpointNumber = published.checkpoint.number;
+        // Per-block tx-collection records (true | false | undefined) for every block in this
+        // published checkpoint. Captured by the validator's proposal handler at the moment of
+        // tx collection (i.e. by the *re-execution* deadline). Used as a positive short-circuit
+        // only: a `true` for every block means we know the data was available locally, so this
+        // checkpoint cannot be a data-withholding offense. A `false` does *not* trigger a slash
+        // on its own — the re-execution deadline is much earlier than the data-withholding
+        // tolerance window, so missing txs at that earlier deadline may still arrive in time.
+        // Anything other than all-true falls through to the mempool probe, which respects the
+        // tolerance window.
+        const collectionRecords = published.checkpoint.blocks.map((block, idx)=>this.reexecutionTracker.getTxsCollectedRecord(block.header.getSlot(), idx));
+        if (collectionRecords.every((r)=>r === true)) {
+            this.log.trace(`All blocks for checkpoint at slot ${slot} were collected locally; skipping`, {
+                slot,
+                checkpointNumber
+            });
+            return;
+        }
+        const txHashes = published.checkpoint.blocks.flatMap((block)=>block.body.txEffects.map((txEffect)=>txEffect.txHash));
+        if (txHashes.length === 0) {
+            this.log.trace(`Checkpoint at slot ${slot} has no txs`, {
+                slot
+            });
+            return;
+        }
+        const availability = await this.txProvider.hasTxs(txHashes);
+        const missingTxs = txHashes.filter((_, i)=>!availability[i]);
+        if (missingTxs.length === 0) {
+            this.log.trace(`All ${txHashes.length} txs available for checkpoint at slot ${slot}`, {
+                slot
+            });
+            return;
+        }
+        const attesters = await this.extractAttesters(published);
+        if (attesters.length === 0) {
+            this.log.warn(`Detected data withholding at slot ${slot} but no recoverable attesters`, {
+                slot,
+                checkpointNumber,
+                missingTxs: missingTxs.map((h)=>h.toString()),
+                records: collectionRecords
+            });
+            return;
+        }
+        this.log.info(`Detected data withholding offense at slot ${slot}`, {
+            slot,
+            checkpointNumber,
+            amount: this.config.slashDataWithholdingPenalty,
+            offenseType: getOffenseTypeName(OffenseType.DATA_WITHHOLDING),
+            missingTxs: missingTxs.map((h)=>h.toString()),
+            records: collectionRecords,
+            attesters: attesters.map((a)=>a.toString())
+        });
+        const args = attesters.map((validator)=>({
+                validator,
+                amount: this.config.slashDataWithholdingPenalty,
+                offenseType: OffenseType.DATA_WITHHOLDING,
+                epochOrSlot: BigInt(slot)
+            }));
+        this.emit(WANT_TO_SLASH_EVENT, args);
+    }
+    /**
+   * Returns the union of:
+   *   1. attesters whose signatures landed in the published checkpoint on L1, and
+   *   2. attesters we observed signing the same proposal on p2p (the proposer publishes as
+   *      soon as it has hit committee quorum, so honest peer attestations that arrive after
+   *      that point are dropped — but they still vouched for the data and
+   *      should be slashed for withholding it).
+   *
+   *
+   * Exposed as protected so tests can substitute a deterministic recovery without having
+   * to construct real secp256k1 signatures.
+   */ async extractAttesters(published) {
+        const fromL1 = getAttestationInfoFromPublishedCheckpoint(published, this.signatureContext).filter((info)=>info.status === 'recovered-from-signature').map((info)=>info.address);
+        const slot = published.checkpoint.header.slotNumber;
+        const proposalPayloadHash = CheckpointProposalHash.fromBuffer(ConsensusPayload.fromCheckpoint(published.checkpoint, this.signatureContext).getPayloadHash());
+        const fromP2p = await this.p2p.getCheckpointAttestationsForSlot(slot, proposalPayloadHash).then((attestations)=>attestations.map((a)=>a.getSender()));
+        // Dedupe
+        const all = new Map();
+        for (const addr of compactArray([
+            ...fromL1,
+            ...fromP2p
+        ])){
+            all.set(addr.toString(), addr);
+        }
+        return [
+            ...all.values()
+        ];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/slasher",
-  "version": "0.0.1-commit.b2a5d0dd1",
+  "version": "0.0.1-commit.b3d3157a",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -56,20 +56,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/epoch-cache": "0.0.1-commit.b2a5d0dd1",
-    "@aztec/ethereum": "0.0.1-commit.b2a5d0dd1",
-    "@aztec/foundation": "0.0.1-commit.b2a5d0dd1",
-    "@aztec/kv-store": "0.0.1-commit.b2a5d0dd1",
-    "@aztec/l1-artifacts": "0.0.1-commit.b2a5d0dd1",
-    "@aztec/stdlib": "0.0.1-commit.b2a5d0dd1",
-    "@aztec/telemetry-client": "0.0.1-commit.b2a5d0dd1",
+    "@aztec/epoch-cache": "0.0.1-commit.b3d3157a",
+    "@aztec/ethereum": "0.0.1-commit.b3d3157a",
+    "@aztec/foundation": "0.0.1-commit.b3d3157a",
+    "@aztec/kv-store": "0.0.1-commit.b3d3157a",
+    "@aztec/l1-artifacts": "0.0.1-commit.b3d3157a",
+    "@aztec/stdlib": "0.0.1-commit.b3d3157a",
+    "@aztec/telemetry-client": "0.0.1-commit.b3d3157a",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2",
-    "zod": "^3.23.8"
+    "zod": "^4"
   },
   "devDependencies": {
-    "@aztec/aztec.js": "0.0.1-commit.b2a5d0dd1",
+    "@aztec/aztec.js": "0.0.1-commit.b3d3157a",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/config.ts

@@ -16,16 +16,22 @@ export const DefaultSlasherConfig: SlasherConfig = {
   slashOverridePayload: undefined,
   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,
@@ -63,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.',
@@ -113,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' | 'registryAddress'>,
+  l1Contracts: Pick<L1ReaderConfig, 'rollupAddress' | 'registryAddress'>,
   l1Client: ViemClient,
   watchers: Watcher[],
   dateProvider: DateProvider,

package/src/generated/slasher-defaults.ts

@@ -6,16 +6,18 @@ export const slasherDefaultEnv = {
   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,6 +1,9 @@
 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 './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';

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/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, 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();
   }
 
   /**
@@ -74,24 +89,39 @@ export class SlashOffensesCollector {
       };
 
       if (this.shouldSkipOffense(offense)) {
-        this.log.verbose('Skipping offense during grace period', offense);
-        continue;
-      }
-
-      if (await this.offensesStore.hasOffense(offense)) {
-        this.log.debug('Skipping repeated offense', 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}`, offense);
-      await this.offensesStore.addOffense(offense);
+  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()),
+        });
+      }
     }
   }
 
@@ -111,4 +141,16 @@ export class SlashOffensesCollector {
     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));
+  }
 }

package/src/slasher_client.ts

@@ -14,11 +14,14 @@ import {
   type ProposerSlashAction,
   type ProposerSlashActionProvider,
   getEpochsForRound,
+  getOffenseTypeName,
   getSlashConsensusVotesFromOffenses,
 } from '@aztec/stdlib/slashing';
+import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { Hex } from 'viem';
 
+import { SlasherMetrics } from './metrics.js';
 import {
   SlashOffensesCollector,
   type SlashOffensesCollectorConfig,
@@ -50,6 +53,14 @@ export type SlasherClientConfig = SlashOffensesCollectorConfig &
     'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack' | 'slashMaxPayloadSize'
   >;
 
+type AlwaysSlashOffense = {
+  validator: EthAddress;
+  amount: bigint;
+  offenseType: OffenseType.UNKNOWN;
+};
+
+type SlashVoteOffense = Offense | AlwaysSlashOffense;
+
 /**
  * The Slasher client is responsible for managing slashable offenses using
  * the consensus-based slashing model where proposers vote on individual validator offenses.
@@ -92,6 +103,7 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
     private dateProvider: DateProvider,
     private offensesStore: SlasherOffensesStore,
     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);
@@ -152,6 +164,7 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
 
   /** Called when we see a RoundExecuted event on the SlashingProposer (just for logging). */
   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 });
   }
@@ -309,7 +322,7 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
     // 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,
@@ -323,7 +336,7 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
         slotNumber,
         currentRound,
         slashedRound,
-        offensesToForgive,
+        offensesFromAlwaysSlash: offensesFromAlwaysSlash.map(getOffenseLogData),
         slashValidatorsAlways: this.config.slashValidatorsAlways,
       });
     }
@@ -333,7 +346,7 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
         slotNumber,
         currentRound,
         slashedRound,
-        offensesToForgive,
+        offensesToForgive: offensesToForgive.map(getOffenseLogData),
         slashValidatorsNever: this.config.slashValidatorsNever,
       });
     }
@@ -343,11 +356,11 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
       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);
@@ -365,12 +378,20 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
         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,
@@ -429,3 +450,11 @@ export class SlasherClient implements ProposerSlashActionProvider, SlasherClient
     return round - BigInt(this.settings.slashingOffsetInRounds);
   }
 }
+
+function getOffenseLogData(offense: SlashVoteOffense) {
+  return {
+    ...offense,
+    validator: offense.validator.toString(),
+    offenseType: getOffenseTypeName(offense.offenseType),
+  };
+}