@aztec/slasher 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/dest/watchers/checkpoint_equivocation_watcher.js

@@ -0,0 +1,69 @@
+import { merge, pick } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { L2BlockSourceEvents } from '@aztec/stdlib/block';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
+import EventEmitter from 'node:events';
+import { WANT_TO_SLASH_EVENT } from '../watcher.js';
+const CheckpointEquivocationWatcherConfigKeys = [
+    'slashDuplicateProposalPenalty'
+];
+/**
+ * Slashes the slot proposer for DUPLICATE_PROPOSAL when the archiver detects that a
+ * locally-stored proposed checkpoint disagrees with the L1-confirmed checkpoint at the
+ * same slot. Both are signed by the slot proposer (the proposed one by accepting it via
+ * P2P or building it locally; the L1 one by submission), so the proposer equivocated.
+ */ export class CheckpointEquivocationWatcher extends EventEmitter {
+    l2BlockSource;
+    epochCache;
+    log;
+    handler;
+    config;
+    constructor(l2BlockSource, epochCache, config){
+        super(), this.l2BlockSource = l2BlockSource, this.epochCache = epochCache, this.log = createLogger('checkpoint-equivocation-watcher');
+        this.config = pick(config, ...CheckpointEquivocationWatcherConfigKeys);
+        this.handler = (event)=>{
+            this.onEquivocationDetected(event).catch((err)=>this.log.error('Failed to handle checkpoint equivocation event', err));
+        };
+        this.log.info('CheckpointEquivocationWatcher initialized');
+    }
+    updateConfig(config) {
+        this.config = merge(this.config, pick(config, ...CheckpointEquivocationWatcherConfigKeys));
+        this.log.verbose('CheckpointEquivocationWatcher config updated', this.config);
+    }
+    start() {
+        this.l2BlockSource.events.on(L2BlockSourceEvents.CheckpointEquivocationDetected, this.handler);
+        return Promise.resolve();
+    }
+    stop() {
+        this.l2BlockSource.events.off(L2BlockSourceEvents.CheckpointEquivocationDetected, this.handler);
+        return Promise.resolve();
+    }
+    /** Public for tests. */ async onEquivocationDetected(event) {
+        const proposer = await this.epochCache.getProposerAttesterAddressInSlot(event.slotNumber);
+        if (!proposer) {
+            this.log.warn(`Cannot attribute checkpoint equivocation: no proposer for slot ${event.slotNumber}`, {
+                slotNumber: event.slotNumber,
+                checkpointNumber: event.checkpointNumber
+            });
+            return;
+        }
+        const slashArgs = {
+            validator: proposer,
+            amount: this.config.slashDuplicateProposalPenalty,
+            offenseType: OffenseType.DUPLICATE_PROPOSAL,
+            epochOrSlot: BigInt(event.slotNumber)
+        };
+        this.log.info(`Detected checkpoint equivocation offense`, {
+            slotNumber: event.slotNumber,
+            checkpointNumber: event.checkpointNumber,
+            amount: slashArgs.amount,
+            offenseType: getOffenseTypeName(slashArgs.offenseType),
+            l1ArchiveRoot: event.l1ArchiveRoot.toString(),
+            proposedArchiveRoot: event.proposedArchiveRoot.toString(),
+            validator: proposer.toString()
+        });
+        this.emit(WANT_TO_SLASH_EVENT, [
+            slashArgs
+        ]);
+    }
+}

package/dest/watchers/data_withholding_watcher.d.ts

@@ -0,0 +1,63 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger } from '@aztec/foundation/log';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { CheckpointReexecutionTracker, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { ITxProvider, P2PApi, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import { type CoordinationSignatureContext } from '@aztec/stdlib/p2p';
+import { type Watcher, type WatcherEmitter } from '../watcher.js';
+declare const DataWithholdingWatcherConfigKeys: readonly ["slashDataWithholdingPenalty", "slashDataWithholdingToleranceSlots"];
+type DataWithholdingWatcherConfig = Pick<SlasherConfig, (typeof DataWithholdingWatcherConfigKeys)[number]>;
+declare const DataWithholdingWatcher_base: new () => WatcherEmitter;
+/**
+ * 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 declare class DataWithholdingWatcher extends DataWithholdingWatcher_base implements Watcher {
+    private readonly epochCache;
+    private readonly l2BlockSource;
+    private readonly txProvider;
+    private readonly p2p;
+    private readonly reexecutionTracker;
+    private readonly signatureContext;
+    private readonly log;
+    private runningPromise;
+    private initialSlot;
+    private lastCheckedSlot;
+    private config;
+    constructor(epochCache: EpochCache, l2BlockSource: Pick<L2BlockSource, 'getCheckpoint' | 'getSyncedL2SlotNumber'>, txProvider: Pick<ITxProvider, 'hasTxs'>, p2p: Pick<P2PApi, 'getCheckpointAttestationsForSlot'>, reexecutionTracker: Pick<CheckpointReexecutionTracker, 'getTxsCollectedRecord'>, signatureContext: CoordinationSignatureContext, config: DataWithholdingWatcherConfig, log?: Logger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    updateConfig(config: Partial<SlasherConfig>): void;
+    /**
+     * 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.
+     */
+    work(): Promise<void>;
+    private processSlot;
+    /**
+     * 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.
+     */
+    protected extractAttesters(published: PublishedCheckpoint): Promise<EthAddress[]>;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dest/watchers/data_withholding_watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_withholding_watcher.d.ts","sourceRoot":"","sources":["../../src/watchers/data_withholding_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,4BAA4B,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAClG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAC1F,OAAO,EAAoB,KAAK,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAMxF,OAAO,EAA6C,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7G,QAAA,MAAM,gCAAgC,gFAAiF,CAAC;AAExH,KAAK,4BAA4B,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,gCAAgC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;;AAE3G;;;;;;;;;;;;;GAaG;AACH,qBAAa,sBAAuB,SAAQ,2BAA2C,YAAW,OAAO;IAOrG,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAEjC,OAAO,CAAC,QAAQ,CAAC,GAAG;IAbtB,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,MAAM,CAA+B;IAE7C,YACmB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,eAAe,GAAG,uBAAuB,CAAC,EAC7E,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,EACvC,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,kCAAkC,CAAC,EACrD,kBAAkB,EAAE,IAAI,CAAC,4BAA4B,EAAE,uBAAuB,CAAC,EAC/E,gBAAgB,EAAE,4BAA4B,EAC/D,MAAM,EAAE,4BAA4B,EACnB,GAAG,GAAE,MAAiD,EAOxE;IAEY,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAQlC;IAEM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAGxD;IAED;;;OAGG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA8BjC;YAGa,WAAW;IA6EzB;;;;;;;;;;;OAWG;IACH,UAAgB,gBAAgB,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAmBtF;CACF"}

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.c31f2472",
+  "version": "0.0.1-commit.c52d6e7",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -56,20 +56,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/epoch-cache": "0.0.1-commit.c31f2472",
-    "@aztec/ethereum": "0.0.1-commit.c31f2472",
-    "@aztec/foundation": "0.0.1-commit.c31f2472",
-    "@aztec/kv-store": "0.0.1-commit.c31f2472",
-    "@aztec/l1-artifacts": "0.0.1-commit.c31f2472",
-    "@aztec/stdlib": "0.0.1-commit.c31f2472",
-    "@aztec/telemetry-client": "0.0.1-commit.c31f2472",
+    "@aztec/epoch-cache": "0.0.1-commit.c52d6e7",
+    "@aztec/ethereum": "0.0.1-commit.c52d6e7",
+    "@aztec/foundation": "0.0.1-commit.c52d6e7",
+    "@aztec/kv-store": "0.0.1-commit.c52d6e7",
+    "@aztec/l1-artifacts": "6.0.0-nightly.20260807",
+    "@aztec/stdlib": "0.0.1-commit.c52d6e7",
+    "@aztec/telemetry-client": "0.0.1-commit.c52d6e7",
     "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.c31f2472",
+    "@aztec/aztec.js": "0.0.1-commit.c52d6e7",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/config.ts

@@ -14,18 +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,
@@ -38,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.',
@@ -73,21 +69,38 @@ 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.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashDuplicateProposalPenalty),
+  },
+  slashDuplicateAttestationPenalty: {
+    env: 'SLASH_DUPLICATE_ATTESTATION_PENALTY',
+    description:
+      'Penalty amount for slashing a validator for signing attestations for different proposals at the same slot.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashDuplicateAttestationPenalty),
+  },
   slashInactivityTargetPercentage: {
     env: 'SLASH_INACTIVITY_TARGET_PERCENTAGE',
     description:
@@ -112,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: {
@@ -142,7 +160,8 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
     ...numberConfigHelper(DefaultSlasherConfig.slashMaxPayloadSize),
   },
   slashGracePeriodL2Slots: {
-    description: 'Number of L2 slots to wait before considering a slashing offense expired.',
+    description:
+      'Number of L2 slots after the network upgrade during which slashing offenses are ignored. The upgrade time is determined from the CanonicalRollupUpdated event.',
     env: 'SLASH_GRACE_PERIOD_L2_SLOTS',
     ...numberConfigHelper(DefaultSlasherConfig.slashGracePeriodL2Slots),
   },

package/src/factory/create_facade.ts

@@ -1,14 +1,16 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import { RollupContract } from '@aztec/ethereum/contracts';
+import { RegistryContract, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
 import type { ViemClient } from '@aztec/ethereum/types';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { unique } from '@aztec/foundation/collection';
 import { 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 { createStore } from '@aztec/kv-store/lmdb-v2';
+import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
 import { SlasherClientFacade } from '../slasher_client_facade.js';
 import type { SlasherClientInterface } from '../slasher_client_interface.js';
@@ -18,12 +20,15 @@ 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'>,
+  l1Contracts: Pick<L1ReaderConfig, 'rollupAddress' | 'registryAddress'>,
   l1Client: ViemClient,
   watchers: Watcher[],
   dateProvider: DateProvider,
   epochCache: EpochCache,
-  /** List of own validator addresses to add to the slashValidatorNever list unless slashSelfAllowed is true */
+  /**
+   * List of own validator addresses. Added to the slashValidatorNever list unless slashSelfAllowed is true, and used
+   * (independently of slashSelfAllowed) to warn and record metrics when they are targeted by onchain slashing.
+   */
   validatorAddresses: EthAddress[] = [],
   logger = createLogger('slasher'),
 ): Promise<SlasherClientInterface> {
@@ -34,6 +39,32 @@ export async function createSlasherFacade(
   const kvStore = await createStore('slasher', SCHEMA_VERSION, config, logger.getBindings());
   const rollup = new RollupContract(l1Client, l1Contracts.rollupAddress);
 
+  // Compute and cache the L2 slot at which the rollup was registered as canonical
+  const settingsMap = kvStore.openMap<string, number>('slasher-settings');
+  const cacheKey = `registeredSlot:${l1Contracts.rollupAddress}`;
+  let rollupRegisteredAtL2Slot = (await settingsMap.getAsync(cacheKey)) as SlotNumber | undefined;
+
+  if (rollupRegisteredAtL2Slot === undefined) {
+    const registry = new RegistryContract(l1Client, l1Contracts.registryAddress);
+    const l1StartBlock = await rollup.getL1StartBlock();
+    const registrationTimestamp = await registry.getCanonicalRollupRegistrationTimestamp(
+      l1Contracts.rollupAddress,
+      l1StartBlock,
+    );
+    if (registrationTimestamp !== undefined) {
+      const l1GenesisTime = await rollup.getL1GenesisTime();
+      const slotDuration = await rollup.getSlotDuration();
+      rollupRegisteredAtL2Slot = getSlotAtTimestamp(registrationTimestamp, {
+        l1GenesisTime,
+        slotDuration: Number(slotDuration),
+      });
+    } else {
+      rollupRegisteredAtL2Slot = SlotNumber(0);
+    }
+    await settingsMap.set(cacheKey, rollupRegisteredAtL2Slot);
+    logger.info(`Canonical rollup registered at L2 slot ${rollupRegisteredAtL2Slot}`);
+  }
+
   const slashValidatorsNever = config.slashSelfAllowed
     ? config.slashValidatorsNever
     : unique([...config.slashValidatorsNever, ...validatorAddresses].map(a => a.toString())).map(EthAddress.fromString);
@@ -43,11 +74,12 @@ export async function createSlasherFacade(
     updatedConfig,
     rollup,
     l1Client,
-    l1Contracts.slashFactoryAddress,
     watchers,
     epochCache,
     dateProvider,
     kvStore,
+    rollupRegisteredAtL2Slot,
+    validatorAddresses,
     logger,
   );
 }