@aztec-labs/slasher 6.0.0-nightly.20260829

package/dest/watchers/data_withholding_watcher.js

@@ -0,0 +1,223 @@
+import { CheckpointProposalHash, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { compactArray, merge, pick } from '@aztec-labs/foundation/collection';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { RunningPromise } from '@aztec-labs/foundation/promise';
+import { getAttestationInfoFromPublishedCheckpoint } from '@aztec-labs/stdlib/block';
+import { ConsensusPayload } from '@aztec-labs/stdlib/p2p';
+import { OffenseType, getOffenseTypeName } from '@aztec-labs/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.
+ *
+ * Since the evidence for an offense is the absence of txs in the local pool, the probe is gated on
+ * p2p connectivity: while there are no connected peers, slots are skipped instead of probed, since
+ * missing txs then say nothing about the attesters. Nodes running with p2p disabled do not run this
+ * watcher at all.
+ */ export class DataWithholdingWatcher extends EventEmitter {
+    epochCache;
+    l2BlockSource;
+    txProvider;
+    p2p;
+    reexecutionTracker;
+    signatureContext;
+    log;
+    runningPromise;
+    initialSlot;
+    lastCheckedSlot;
+    config;
+    gossipDegraded;
+    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.gossipDegraded = false;
+        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;
+        }
+        // Missing txs are only evidence of withholding if we could have received them. Slots probed
+        // while gossip is down are skipped for good rather than deferred: once peers return, txs from
+        // those checkpoints may already have been evicted from the pool as mined, so a late probe would
+        // still report them missing. An unknown must not turn into an offense. Note this deliberately
+        // ignores whether p2p is enabled: a node with no p2p stack sees even less than a peerless one.
+        const connectivity = await this.p2p.getP2PConnectivity();
+        if (connectivity.connectedPeers === 0) {
+            if (!this.gossipDegraded) {
+                this.gossipDegraded = true;
+                this.log.warn(`Skipping data-withholding checks while no peers are connected`, {
+                    targetSlot,
+                    lastCheckedSlot: this.lastCheckedSlot
+                });
+            }
+            this.lastCheckedSlot = targetSlot;
+            return;
+        }
+        if (this.gossipDegraded) {
+            this.gossipDegraded = false;
+            this.log.info(`Resuming data-withholding checks now that peers are connected`, {
+                targetSlot,
+                connectedPeers: connectivity.connectedPeers
+            });
+        }
+        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

@@ -0,0 +1,90 @@
+{
+  "name": "@aztec-labs/slasher",
+  "version": "6.0.0-nightly.20260829",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./config": "./dest/config.js"
+  },
+  "inherits": [
+    "../package.common.json",
+    "./package.local.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "bb": "node --no-warnings ./dest/bb/index.js",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "generate": "./scripts/generate.sh"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/epoch-cache": "6.0.0-nightly.20260829",
+    "@aztec-labs/ethereum": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/kv-store": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@aztec-labs/telemetry-client": "6.0.0-nightly.20260829",
+    "source-map-support": "^0.5.21",
+    "tslib": "^2.4.0",
+    "viem": "npm:@aztec/viem@2.38.2",
+    "zod": "^4"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@types/source-map-support": "^0.5.10",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/config.ts

@@ -0,0 +1,177 @@
+import type { ConfigMappingsType } from '@aztec-labs/foundation/config';
+import {
+  bigintConfigHelper,
+  booleanConfigHelper,
+  floatConfigHelper,
+  numberConfigHelper,
+} from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+
+import { slasherDefaultEnv } from './generated/slasher-defaults.js';
+
+export type { SlasherConfig };
+
+export const DefaultSlasherConfig: SlasherConfig = {
+  slashOverridePayload: undefined,
+  slashValidatorsAlways: [], // Empty by default
+  slashValidatorsNever: [], // Empty by default
+  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),
+  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,
+  slashGracePeriodL2Slots: slasherDefaultEnv.SLASH_GRACE_PERIOD_L2_SLOTS,
+  slashExecuteRoundsLookBack: slasherDefaultEnv.SLASH_EXECUTE_ROUNDS_LOOK_BACK,
+  slashSelfAllowed: false,
+};
+
+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) => EthAddress.fromString(val),
+    defaultValue: DefaultSlasherConfig.slashOverridePayload,
+  },
+  slashValidatorsAlways: {
+    env: 'SLASH_VALIDATORS_ALWAYS',
+    description: 'Comma-separated list of validator addresses that should always be slashed.',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(addr => addr.trim())
+        .filter(addr => addr.length > 0)
+        .map(addr => EthAddress.fromString(addr)),
+    defaultValue: DefaultSlasherConfig.slashValidatorsAlways,
+  },
+  slashValidatorsNever: {
+    env: 'SLASH_VALIDATORS_NEVER',
+    description: 'Comma-separated list of validator addresses that should never be slashed.',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(addr => addr.trim())
+        .filter(addr => addr.length > 0)
+        .map(addr => EthAddress.fromString(addr)),
+    defaultValue: DefaultSlasherConfig.slashValidatorsNever,
+  },
+  slashDataWithholdingPenalty: {
+    env: 'SLASH_DATA_WITHHOLDING_PENALTY',
+    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:
+      'Missed attestation percentage to trigger creation of inactivity slash payload (0, 1]. Must be greater than 0',
+    ...floatConfigHelper(DefaultSlasherConfig.slashInactivityTargetPercentage, v => {
+      if (v <= 0 || v > 1) {
+        throw new RangeError(`SLASH_INACTIVITY_TARGET_PERCENTAGE out of range. Expected (0, 1] got ${v}`);
+      }
+    }),
+  },
+  slashInactivityConsecutiveEpochThreshold: {
+    env: 'SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD',
+    description: 'Number of consecutive epochs a validator must be inactive before slashing (minimum 1).',
+    ...numberConfigHelper(DefaultSlasherConfig.slashInactivityConsecutiveEpochThreshold),
+    parseEnv: (val: string) => {
+      const parsed = parseInt(val, 10);
+      if (parsed < 1) {
+        throw new RangeError(`SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD must be at least 1 (got ${parsed})`);
+      }
+      return parsed;
+    },
+  },
+  slashInactivityPenalty: {
+    env: 'SLASH_INACTIVITY_PENALTY',
+    description: 'Penalty for an inactive validator (0 records offenses without slash votes).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashInactivityPenalty),
+  },
+  slashProposeInvalidAttestationsPenalty: {
+    env: 'SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY',
+    description: 'Penalty for proposing invalid attestations (0 records offenses without slash votes).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashProposeInvalidAttestationsPenalty),
+  },
+  slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty: {
+    env: 'SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY',
+    description:
+      '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 for an unknown offense (0 records offenses without slash votes).',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashUnknownPenalty),
+  },
+  slashOffenseExpirationRounds: {
+    env: 'SLASH_OFFENSE_EXPIRATION_ROUNDS',
+    description: 'Number of rounds after which pending offenses expire.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashOffenseExpirationRounds),
+  },
+  slashMaxPayloadSize: {
+    env: 'SLASH_MAX_PAYLOAD_SIZE',
+    description: 'Maximum number of offenses to include in a single slash payload.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashMaxPayloadSize),
+  },
+  slashGracePeriodL2Slots: {
+    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),
+  },
+  slashExecuteRoundsLookBack: {
+    env: 'SLASH_EXECUTE_ROUNDS_LOOK_BACK',
+    description: 'How many rounds to look back when searching for a round to execute.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashExecuteRoundsLookBack),
+  },
+  slashSelfAllowed: {
+    description: 'Whether to allow slashes to own validators',
+    ...booleanConfigHelper(DefaultSlasherConfig.slashSelfAllowed),
+  },
+};

package/src/factory/create_facade.ts

@@ -0,0 +1,85 @@
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { RegistryContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import type { L1ReaderConfig } from '@aztec-labs/ethereum/l1-reader';
+import type { ViemClient } from '@aztec-labs/ethereum/types';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { unique } from '@aztec-labs/foundation/collection';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { createStore } from '@aztec-labs/kv-store/lmdb-v2';
+import { getSlotAtTimestamp } from '@aztec-labs/stdlib/epoch-helpers';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+
+import { SlasherClientFacade } from '../slasher_client_facade.js';
+import type { SlasherClientInterface } from '../slasher_client_interface.js';
+import { SCHEMA_VERSION } from '../stores/schema_version.js';
+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, 'rollupAddress' | 'registryAddress'>,
+  l1Client: ViemClient,
+  watchers: Watcher[],
+  dateProvider: DateProvider,
+  epochCache: EpochCache,
+  /**
+   * 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> {
+  if (!l1Contracts.rollupAddress || l1Contracts.rollupAddress.equals(EthAddress.ZERO)) {
+    throw new Error('Cannot initialize SlasherClient without a Rollup address');
+  }
+
+  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);
+  const updatedConfig = { ...config, slashValidatorsNever };
+
+  return new SlasherClientFacade(
+    updatedConfig,
+    rollup,
+    l1Client,
+    watchers,
+    epochCache,
+    dateProvider,
+    kvStore,
+    rollupRegisteredAtL2Slot,
+    validatorAddresses,
+    logger,
+  );
+}

package/src/factory/create_implementation.ts

@@ -0,0 +1,83 @@
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { RollupContract, SlashingProposerContract } from '@aztec-labs/ethereum/contracts';
+import type { ViemClient } from '@aztec-labs/ethereum/types';
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { AztecLMDBStoreV2 } from '@aztec-labs/kv-store/lmdb-v2';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+
+import { NullSlasherClient } from '../null_slasher_client.js';
+import { SlasherClient } from '../slasher_client.js';
+import { SlasherOffensesStore } from '../stores/offenses_store.js';
+import type { Watcher } from '../watcher.js';
+import { getSlasherSettings } from './get_settings.js';
+
+/** 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,
+  watchers: Watcher[],
+  epochCache: EpochCache,
+  dateProvider: DateProvider,
+  kvStore: AztecLMDBStoreV2,
+  rollupRegisteredAtL2Slot: SlotNumber,
+  ownValidators: EthAddress[] = [],
+  logger = createLogger('slasher'),
+) {
+  const proposer = await rollup.getSlashingProposer();
+  if (!proposer) {
+    return new NullSlasherClient(config);
+  } else {
+    return createSlasher(
+      config,
+      rollup,
+      proposer,
+      watchers,
+      dateProvider,
+      epochCache,
+      kvStore,
+      rollupRegisteredAtL2Slot,
+      ownValidators,
+      logger,
+    );
+  }
+}
+
+async function createSlasher(
+  config: SlasherConfig & DataStoreConfig,
+  rollup: RollupContract,
+  slashingProposer: SlashingProposerContract,
+  watchers: Watcher[],
+  dateProvider: DateProvider,
+  epochCache: EpochCache,
+  kvStore: AztecLMDBStoreV2,
+  rollupRegisteredAtL2Slot: SlotNumber,
+  ownValidators: EthAddress[] = [],
+  logger = createLogger('slasher'),
+): Promise<SlasherClient> {
+  const settings = { ...(await getSlasherSettings(rollup, slashingProposer)), rollupRegisteredAtL2Slot };
+  const slasher = await rollup.getSlasherContract();
+
+  const offensesStore = new SlasherOffensesStore(kvStore, {
+    ...settings,
+    slashOffenseExpirationRounds: config.slashOffenseExpirationRounds,
+  });
+
+  return new SlasherClient(
+    config,
+    settings,
+    slashingProposer,
+    slasher!,
+    rollup,
+    watchers,
+    epochCache,
+    dateProvider,
+    offensesStore,
+    ownValidators,
+    logger,
+  );
+}