@aztec-labs/slasher 6.0.0-nightly.20260829

package/dest/slash_round_monitor.js

@@ -0,0 +1,52 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { getSlotAtTimestamp } from '@aztec-labs/stdlib/epoch-helpers';
+import { getRoundForSlot } from '@aztec-labs/stdlib/slashing';
+export class SlashRoundMonitor {
+    settings;
+    dateProvider;
+    log;
+    currentRound;
+    intervalId;
+    handler;
+    constructor(settings, dateProvider, log = createLogger('slasher:round-monitor')){
+        this.settings = settings;
+        this.dateProvider = dateProvider;
+        this.log = log;
+        this.currentRound = 0n;
+        this.intervalId = undefined;
+        this.handler = undefined;
+    }
+    start() {
+        // Check for round changes
+        this.currentRound = this.getCurrentRound().round;
+        this.intervalId = setInterval(()=>{
+            const round = this.getCurrentRound().round;
+            if (round !== this.currentRound) {
+                this.currentRound = round;
+                if (this.handler) {
+                    void this.handler(round).catch((err)=>this.log.error('Error handling new round', err));
+                }
+            }
+        }, 500);
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    listenToNewRound(handler) {
+        this.handler = handler;
+        return ()=>{
+            this.handler = undefined;
+        };
+    }
+    /** Returns the slashing round number and the voting slot within the round based on the L2 chain slot */ getRoundForSlot(slotNumber) {
+        return getRoundForSlot(slotNumber, this.settings);
+    }
+    /** Returns the current slashing round and voting slot within the round */ getCurrentRound() {
+        const now = this.dateProvider.nowInSeconds();
+        const currentSlot = getSlotAtTimestamp(BigInt(now), this.settings);
+        return this.getRoundForSlot(currentSlot);
+    }
+}

package/dest/slasher_client.d.ts

@@ -0,0 +1,118 @@
+import type { EpochCache } from '@aztec-labs/epoch-cache';
+import { RollupContract, SlasherContract, SlashingProposerContract } from '@aztec-labs/ethereum/contracts';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { Prettify } from '@aztec-labs/foundation/types';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+import { type Offense, type ProposerSlashAction, type ProposerSlashActionProvider } from '@aztec-labs/stdlib/slashing';
+import type { Hex } from 'viem';
+import { SlasherMetrics } from './metrics.js';
+import { OwnValidatorSlashMonitor } from './own_validator_slash_monitor.js';
+import { SlashOffensesCollector, type SlashOffensesCollectorConfig, type SlashOffensesCollectorSettings } from './slash_offenses_collector.js';
+import { SlashRoundMonitor, type SlashRoundMonitorSettings } from './slash_round_monitor.js';
+import type { SlasherClientInterface } from './slasher_client_interface.js';
+import type { SlasherOffensesStore } from './stores/offenses_store.js';
+import type { Watcher } from './watcher.js';
+/** Settings used in the slasher client, loaded from the L1 contracts during initialization */
+export type SlasherSettings = Prettify<SlashRoundMonitorSettings & SlashOffensesCollectorSettings & {
+    slashingLifetimeInRounds: number;
+    slashingExecutionDelayInRounds: number;
+    slashingRoundSizeInEpochs: number;
+    slashingOffsetInRounds: number;
+    slashingQuorumSize: number;
+    slashingAmounts: [bigint, bigint, bigint];
+    /** Committee size for block proposal */
+    targetCommitteeSize: number;
+}>;
+export type SlasherClientConfig = SlashOffensesCollectorConfig & Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack' | 'slashMaxPayloadSize'>;
+/**
+ * The Slasher client is responsible for managing slashable offenses using
+ * the consensus-based slashing model where proposers vote on individual validator offenses.
+ *
+ * The client subscribes to several slash watchers that emit offenses and tracks them. When the slasher is the
+ * proposer, it votes for which validators from past epochs should be slashed based on collected offenses.
+ * Voting is handled by the sequencer publisher, the slasher client does not interact with L1 directly.
+ * The client also monitors rounds and executes slashing when rounds become executable after reaching quorum.
+ *
+ * Voting and offense collection
+ * - Time is divided into rounds (ROUND_SIZE slots each). During each round, block proposers can submit votes
+ * indicating which validators from SLASH_OFFSET_IN_ROUNDS rounds ago should be slashed.
+ * - Votes are encoded as bytes where each validator's vote is represented by 2 bits indicating the slash amount (0-3 slash units)
+ * for the validator in the committee being slashed.
+ * - When gathering offenses for round N, the system looks at offenses from round N-2 (where 2 is the hardcoded
+ * offset), giving time to detect offenses and vote on them in a later round.
+ * - Each offense carries an epoch or block identifier to differentiate multiple offenses by the same validator.
+ *
+ * Quorum and execution
+ * - After a round ends, there is an execution delay period for review so the VETOER in the Slasher can veto
+ * if needed.
+ * - Once the delay passes, anyone can call executeRound() to tally votes and execute slashing.
+ * - Validators that reach the quorum threshold are slashed. A vote for slashing N units is also considered
+ * a vote for slashing N-1, N-2, ..., 1 units. The system slashes for the largest amount that reaches quorum.
+ * - The client monitors executable rounds and triggers execution when appropriate.
+ */
+export declare class SlasherClient implements ProposerSlashActionProvider, SlasherClientInterface {
+    private config;
+    private settings;
+    private slashingProposer;
+    private slasher;
+    private rollup;
+    private epochCache;
+    private dateProvider;
+    private offensesStore;
+    private readonly ownValidators;
+    private log;
+    private readonly metrics;
+    protected unwatchCallbacks: (() => void)[];
+    protected roundMonitor: SlashRoundMonitor;
+    protected offensesCollector: SlashOffensesCollector;
+    protected readonly ownValidatorMonitor: OwnValidatorSlashMonitor;
+    constructor(config: SlasherClientConfig, settings: SlasherSettings, slashingProposer: SlashingProposerContract, slasher: SlasherContract, rollup: RollupContract, watchers: Watcher[], epochCache: EpochCache, dateProvider: DateProvider, offensesStore: SlasherOffensesStore, ownValidators?: EthAddress[], log?: import("@aztec-labs/foundation/log").Logger, metrics?: SlasherMetrics);
+    start(): Promise<void>;
+    /** Stop the slasher client */
+    stop(): Promise<void>;
+    /** Returns the current config */
+    getConfig(): SlasherConfig;
+    /** Update the config of the slasher client */
+    updateConfig(config: Partial<SlasherConfig>): void;
+    /** Triggered on a time basis when we enter a new slashing round. Clears expired offenses. */
+    protected handleNewRound(round: bigint): Promise<void>;
+    /** Called when we see a RoundExecuted event on the SlashingProposer (just for logging and metrics). */
+    protected handleRoundExecuted(round: bigint, slashCount: bigint, l1BlockHash: Hex): Promise<void>;
+    /**
+     * Get the actions the proposer should take for slashing
+     * @param slotNumber - The current slot number
+     * @returns The actions to take
+     */
+    getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
+    /**
+     * Returns an execute slash action if there are any rounds ready to be executed.
+     * Returns the oldest slash action if there are multiple rounds pending execution.
+     */
+    protected getExecuteSlashAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined>;
+    private tryGetRoundExecuteAction;
+    /** Returns a vote action based on offenses from the target round (with offset applied) */
+    protected getVoteOffensesAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined>;
+    /** Returns the committees that were active during the timespan of a given round */
+    private collectCommitteesActiveDuringRound;
+    /**
+     * Gather offenses to be slashed on a given round.
+     * Round N slashes validators from round N - slashOffsetInRounds.
+     * @param round - The round to get offenses for, defaults to current round
+     * @returns Array of pending offenses for the round with offset applied
+     */
+    gatherOffensesForRound(round?: bigint): Promise<Offense[]>;
+    /** Returns all offenses stored */
+    getOffenses(): Promise<Offense[]>;
+    /**
+     * Returns the round to be slashed given the current round by applying the slash offset.
+     * During round N, we cannot slash the validators from the epochs of the same round, since the round is not over,
+     * and besides we would be asking the current validators to vote to slash themselves. So during round N we look at the
+     * epochs spanned during round N - SLASH_OFFSET_IN_ROUNDS. This offset means that the epochs we slash are complete,
+     * and also gives nodes time to detect any misbehavior (eg slashing for prunes requires the proof submission window to
+     * pass).
+     */
+    private getSlashedRound;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/slasher_client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slasher_client.d.ts","sourceRoot":"","sources":["../src/slasher_client.ts"],"names":[],"mappings":"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"}

package/dest/slasher_client.js

@@ -0,0 +1,373 @@
+import { maxBigint } from '@aztec-labs/foundation/bigint';
+import { compactArray, partition, times } from '@aztec-labs/foundation/collection';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { OffenseType, getEpochsForRound, getOffenseTypeName, getSlashConsensusVotesFromOffenses } from '@aztec-labs/stdlib/slashing';
+import { getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { SlasherMetrics } from './metrics.js';
+import { OwnValidatorSlashMonitor } from './own_validator_slash_monitor.js';
+import { SlashOffensesCollector } from './slash_offenses_collector.js';
+import { SlashRoundMonitor } from './slash_round_monitor.js';
+/**
+ * The Slasher client is responsible for managing slashable offenses using
+ * the consensus-based slashing model where proposers vote on individual validator offenses.
+ *
+ * The client subscribes to several slash watchers that emit offenses and tracks them. When the slasher is the
+ * proposer, it votes for which validators from past epochs should be slashed based on collected offenses.
+ * Voting is handled by the sequencer publisher, the slasher client does not interact with L1 directly.
+ * The client also monitors rounds and executes slashing when rounds become executable after reaching quorum.
+ *
+ * Voting and offense collection
+ * - Time is divided into rounds (ROUND_SIZE slots each). During each round, block proposers can submit votes
+ * indicating which validators from SLASH_OFFSET_IN_ROUNDS rounds ago should be slashed.
+ * - Votes are encoded as bytes where each validator's vote is represented by 2 bits indicating the slash amount (0-3 slash units)
+ * for the validator in the committee being slashed.
+ * - When gathering offenses for round N, the system looks at offenses from round N-2 (where 2 is the hardcoded
+ * offset), giving time to detect offenses and vote on them in a later round.
+ * - Each offense carries an epoch or block identifier to differentiate multiple offenses by the same validator.
+ *
+ * Quorum and execution
+ * - After a round ends, there is an execution delay period for review so the VETOER in the Slasher can veto
+ * if needed.
+ * - Once the delay passes, anyone can call executeRound() to tally votes and execute slashing.
+ * - Validators that reach the quorum threshold are slashed. A vote for slashing N units is also considered
+ * a vote for slashing N-1, N-2, ..., 1 units. The system slashes for the largest amount that reaches quorum.
+ * - The client monitors executable rounds and triggers execution when appropriate.
+ */ export class SlasherClient {
+    config;
+    settings;
+    slashingProposer;
+    slasher;
+    rollup;
+    epochCache;
+    dateProvider;
+    offensesStore;
+    ownValidators;
+    log;
+    metrics;
+    unwatchCallbacks;
+    roundMonitor;
+    offensesCollector;
+    ownValidatorMonitor;
+    constructor(config, settings, slashingProposer, slasher, rollup, watchers, epochCache, dateProvider, offensesStore, ownValidators = [], log = createLogger('slasher:consensus'), metrics = new SlasherMetrics(getTelemetryClient())){
+        this.config = config;
+        this.settings = settings;
+        this.slashingProposer = slashingProposer;
+        this.slasher = slasher;
+        this.rollup = rollup;
+        this.epochCache = epochCache;
+        this.dateProvider = dateProvider;
+        this.offensesStore = offensesStore;
+        this.ownValidators = ownValidators;
+        this.log = log;
+        this.metrics = metrics;
+        this.unwatchCallbacks = [];
+        this.roundMonitor = new SlashRoundMonitor(settings, dateProvider);
+        this.offensesCollector = new SlashOffensesCollector(config, settings, watchers, offensesStore);
+        this.ownValidatorMonitor = new OwnValidatorSlashMonitor(slashingProposer, settings, ownValidators, this.metrics);
+    }
+    async start() {
+        this.log.debug('Starting slasher client...');
+        this.roundMonitor.start();
+        await this.offensesCollector.start();
+        // Listen for RoundExecuted events
+        this.unwatchCallbacks.push(this.slashingProposer.listenToRoundExecuted(({ round, slashCount, l1BlockHash })=>void this.handleRoundExecuted(round, slashCount, l1BlockHash).catch((err)=>this.log.error('Error handling round executed', err))));
+        // Check for round changes
+        this.unwatchCallbacks.push(this.roundMonitor.listenToNewRound((round)=>this.handleNewRound(round)));
+        // Warn early when a slashing vote names one of our own validators. Skipped entirely when running none, so
+        // those nodes pay no extra L1 subscription.
+        if (this.ownValidators.length > 0) {
+            this.ownValidatorMonitor.start(this.roundMonitor.getCurrentRound().round);
+            this.unwatchCallbacks.push(this.slashingProposer.listenToVoteCast(({ round, voteIndex })=>void this.ownValidatorMonitor.handleVoteCast(round, voteIndex)));
+        }
+        this.log.info(`Started slasher client`);
+        return Promise.resolve();
+    }
+    /** Stop the slasher client */ async stop() {
+        this.log.debug('Stopping slasher client...');
+        for (const unwatchCallback of this.unwatchCallbacks){
+            unwatchCallback();
+        }
+        this.roundMonitor.stop();
+        await this.ownValidatorMonitor.stop();
+        await this.offensesCollector.stop();
+        this.log.info('Slasher client stopped');
+    }
+    /** Returns the current config */ getConfig() {
+        return this.config;
+    }
+    /** Update the config of the slasher client */ updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+    /** Triggered on a time basis when we enter a new slashing round. Clears expired offenses. */ async handleNewRound(round) {
+        this.log.info(`Starting new slashing round ${round}`);
+        this.ownValidatorMonitor.handleNewRound(round);
+        await this.offensesCollector.handleNewRound(round);
+    }
+    /** Called when we see a RoundExecuted event on the SlashingProposer (just for logging and metrics). */ async handleRoundExecuted(round, slashCount, l1BlockHash) {
+        this.metrics.recordRoundExecuted();
+        const slashes = await this.rollup.getSlashEvents(l1BlockHash);
+        this.log.info(`Slashing round ${round} has been executed with ${slashCount} slashes`, {
+            slashes
+        });
+        this.ownValidatorMonitor.handleSlashes(round, slashes, l1BlockHash);
+    }
+    /**
+   * Get the actions the proposer should take for slashing
+   * @param slotNumber - The current slot number
+   * @returns The actions to take
+   */ async getProposerActions(slotNumber) {
+        const [executeAction, voteAction] = await Promise.all([
+            this.getExecuteSlashAction(slotNumber),
+            this.getVoteOffensesAction(slotNumber)
+        ]);
+        return compactArray([
+            executeAction,
+            voteAction
+        ]);
+    }
+    /**
+   * Returns an execute slash action if there are any rounds ready to be executed.
+   * Returns the oldest slash action if there are multiple rounds pending execution.
+   */ async getExecuteSlashAction(slotNumber) {
+        const { round: currentRound } = this.roundMonitor.getRoundForSlot(slotNumber);
+        const slashingExecutionDelayInRounds = BigInt(this.settings.slashingExecutionDelayInRounds);
+        const executableRound = currentRound - slashingExecutionDelayInRounds - 1n;
+        const lookBack = BigInt(this.config.slashExecuteRoundsLookBack);
+        const slashingLifetimeInRounds = BigInt(this.settings.slashingLifetimeInRounds);
+        // Compute the oldest executable round considering both lookBack and lifetimeInRounds
+        // A round is only executable if currentRound <= round + lifetimeInRounds
+        // So the oldest round we can execute is: currentRound - lifetimeInRounds
+        const oldestByLifetime = maxBigint(0n, currentRound - slashingLifetimeInRounds);
+        const oldestByLookBack = maxBigint(0n, executableRound - lookBack);
+        const oldestExecutableRound = maxBigint(oldestByLifetime, oldestByLookBack);
+        // Check if slashing is enabled at all
+        if (!await this.slasher.isSlashingEnabled()) {
+            this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`);
+            return undefined;
+        }
+        this.log.debug(`Checking slashing rounds ${oldestExecutableRound} to ${executableRound} to execute`, {
+            slotNumber,
+            currentRound,
+            oldestExecutableRound,
+            oldestByLifetime,
+            oldestByLookBack,
+            executableRound,
+            slashingExecutionDelayInRounds,
+            lookBack,
+            slashingLifetimeInRounds
+        });
+        // Iterate over all rounds, starting from the oldest, until we find one that is executable
+        for(let roundToCheck = oldestExecutableRound; roundToCheck <= executableRound; roundToCheck++){
+            const action = await this.tryGetRoundExecuteAction(roundToCheck, slotNumber);
+            if (action) {
+                return action;
+            }
+        }
+        // And return nothing if none are found
+        return undefined;
+    }
+    /**
+   * Checks if a given round is executable and returns an execute-slash action for it if so.
+   * Assumes round number has already been checked against lifetime and execution delay.
+   * @param executableRound - The round to check for execution
+   */ async tryGetRoundExecuteAction(executableRound, slotNumber) {
+        let logData = {
+            executableRound,
+            slotNumber
+        };
+        this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
+        try {
+            const roundInfo = await this.slashingProposer.getRound(executableRound);
+            logData = {
+                ...logData,
+                roundInfo
+            };
+            if (roundInfo.isExecuted) {
+                this.log.verbose(`Round ${executableRound} has already been executed`, logData);
+                return undefined;
+            } else if (roundInfo.voteCount === 0n) {
+                this.log.debug(`Round ${executableRound} received no votes`, logData);
+                return undefined;
+            } else if (roundInfo.voteCount < this.settings.slashingQuorumSize) {
+                this.log.verbose(`Round ${executableRound} does not have enough votes to execute`, logData);
+                return undefined;
+            }
+            // Check if round is ready to execute at the given slot
+            const isReadyToExecute = await this.slashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
+            if (!isReadyToExecute) {
+                this.log.warn(`Round ${executableRound} is not ready to execute at slot ${slotNumber} according to contract check`, logData);
+                return undefined;
+            }
+            // Check if the round yields any slashing at all
+            const { actions: slashActions, committees } = await this.slashingProposer.getTally(executableRound);
+            if (slashActions.length === 0) {
+                this.log.verbose(`Round ${executableRound} does not resolve in any slashing`, logData);
+                return undefined;
+            }
+            // Check if the slash payload is vetoed
+            const payload = await this.slashingProposer.getPayload(executableRound);
+            const isVetoed = await this.slasher.isPayloadVetoed(payload.address);
+            if (isVetoed) {
+                this.log.warn(`Round ${executableRound} payload is vetoed (skipping execution)`, {
+                    payloadAddress: payload.address.toString(),
+                    ...logData
+                });
+                return undefined;
+            }
+            const slashActionsWithAmounts = slashActions.map((action)=>({
+                    validator: action.validator.toString(),
+                    slashAmount: action.slashAmount.toString()
+                }));
+            this.log.info(`Round ${executableRound} is ready to execute with ${slashActions.length} slashes`, {
+                slashActions: slashActionsWithAmounts,
+                payloadAddress: payload.address.toString(),
+                ...logData
+            });
+            // We only need to post committees that are actually slashed
+            const slashedCommittees = committees.map((c)=>c.some((validator)=>slashActions.some((action)=>action.validator.equals(validator))) ? c : []);
+            this.log.debug(`Collected ${committees.length} committees for executing round ${executableRound}`, {
+                slashedCommittees,
+                ...logData
+            });
+            return {
+                type: 'execute-slash',
+                round: executableRound,
+                committees: slashedCommittees
+            };
+        } catch (error) {
+            this.log.error(`Error checking round to execute ${executableRound}`, error);
+            return undefined;
+        }
+    }
+    /** Returns a vote action based on offenses from the target round (with offset applied) */ async getVoteOffensesAction(slotNumber) {
+        // Compute what round we are in based on the slot number and what round will be slashed
+        const { round: currentRound } = this.roundMonitor.getRoundForSlot(slotNumber);
+        const slashedRound = this.getSlashedRound(currentRound);
+        if (slashedRound < 0n) {
+            return undefined;
+        }
+        // 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)=>({
+                validator,
+                amount: this.settings.slashingAmounts[2],
+                offenseType: OffenseType.UNKNOWN
+            }));
+        const [offensesToForgive, offensesToSlash] = partition([
+            ...offensesForRound,
+            ...offensesFromAlwaysSlash
+        ], (offense)=>this.config.slashValidatorsNever?.some((v)=>v.equals(offense.validator)));
+        if (offensesFromAlwaysSlash.length > 0) {
+            this.log.verbose(`Slashing ${offensesFromAlwaysSlash.length} validators due to always-slash config`, {
+                slotNumber,
+                currentRound,
+                slashedRound,
+                offensesFromAlwaysSlash: offensesFromAlwaysSlash.map(getOffenseLogData),
+                slashValidatorsAlways: this.config.slashValidatorsAlways
+            });
+        }
+        if (offensesToForgive.length > 0) {
+            this.log.verbose(`Skipping slashing of ${offensesToForgive.length} offenses`, {
+                slotNumber,
+                currentRound,
+                slashedRound,
+                offensesToForgive: offensesToForgive.map(getOffenseLogData),
+                slashValidatorsNever: this.config.slashValidatorsNever
+            });
+        }
+        if (offensesToSlash.length === 0) {
+            this.log.debug(`No offenses to slash for round ${slashedRound}`, {
+                currentRound,
+                slotNumber,
+                slashedRound
+            });
+            return undefined;
+        }
+        this.log.debug(`Computing slash votes for ${offensesToSlash.length} offenses`, {
+            slotNumber,
+            currentRound,
+            slashedRound,
+            offensesToSlash: offensesToSlash.map(getOffenseLogData)
+        });
+        const committees = await this.collectCommitteesActiveDuringRound(slashedRound);
+        const epochsForCommittees = getEpochsForRound(slashedRound, this.settings);
+        const { slashMaxPayloadSize } = this.config;
+        const votes = getSlashConsensusVotesFromOffenses(offensesToSlash, committees, epochsForCommittees.map((e)=>BigInt(e)), {
+            ...this.settings,
+            maxSlashedValidators: slashMaxPayloadSize
+        }, this.log);
+        if (votes.every((v)=>v === 0)) {
+            this.log.warn(`Computed votes for offenses are all zero. Skipping vote.`, {
+                slotNumber,
+                currentRound,
+                slashedRound,
+                offensesToSlash: offensesToSlash.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,
+            votes,
+            committees,
+            settings: this.settings
+        });
+        return {
+            type: 'vote-offenses',
+            round: currentRound,
+            votes,
+            committees
+        };
+    }
+    /** Returns the committees that were active during the timespan of a given round */ collectCommitteesActiveDuringRound(round) {
+        const epochsToSlash = getEpochsForRound(round, this.settings);
+        const emptyCommittee = times(Number(this.settings.targetCommitteeSize), ()=>EthAddress.ZERO);
+        return Promise.all(epochsToSlash.map((epoch)=>this.epochCache.getCommitteeForEpoch(epoch).then((c)=>c.committee ?? emptyCommittee)));
+    }
+    /**
+   * Gather offenses to be slashed on a given round.
+   * Round N slashes validators from round N - slashOffsetInRounds.
+   * @param round - The round to get offenses for, defaults to current round
+   * @returns Array of pending offenses for the round with offset applied
+   */ async gatherOffensesForRound(round) {
+        const targetRound = this.getSlashedRound(round);
+        if (targetRound < 0n) {
+            return [];
+        }
+        return await this.offensesStore.getOffensesForRound(targetRound);
+    }
+    /** Returns all offenses stored */ getOffenses() {
+        return this.offensesStore.getOffenses();
+    }
+    /**
+   * Returns the round to be slashed given the current round by applying the slash offset.
+   * During round N, we cannot slash the validators from the epochs of the same round, since the round is not over,
+   * and besides we would be asking the current validators to vote to slash themselves. So during round N we look at the
+   * epochs spanned during round N - SLASH_OFFSET_IN_ROUNDS. This offset means that the epochs we slash are complete,
+   * and also gives nodes time to detect any misbehavior (eg slashing for prunes requires the proof submission window to
+   * pass).
+   */ getSlashedRound(round) {
+        round ??= this.roundMonitor.getCurrentRound().round;
+        return round - BigInt(this.settings.slashingOffsetInRounds);
+    }
+}
+function getOffenseLogData(offense) {
+    return {
+        ...offense,
+        validator: offense.validator.toString(),
+        offenseType: getOffenseTypeName(offense.offenseType)
+    };
+}

package/dest/slasher_client_facade.d.ts

@@ -0,0 +1,44 @@
+import { EpochCache } from '@aztec-labs/epoch-cache';
+import { RollupContract } 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 { 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 type { Offense, ProposerSlashAction } from '@aztec-labs/stdlib/slashing';
+import type { SlasherClientInterface } from './slasher_client_interface.js';
+import type { Watcher } from './watcher.js';
+/**
+ * Facade for the Slasher client. This class forwards all requests to the actual Slasher client implementation.
+ * This class also monitors via the rollup contract when the underlying slasher proposer contract changes, and when it
+ * does, it stops the current slasher client, recreates a new one with the new contract address, and starts it again.
+ */
+export declare class SlasherClientFacade implements SlasherClientInterface {
+    private config;
+    private rollup;
+    private l1Client;
+    private watchers;
+    private epochCache;
+    private dateProvider;
+    private kvStore;
+    private rollupRegisteredAtL2Slot;
+    private ownValidators;
+    private logger;
+    private client;
+    private unwatch;
+    constructor(config: SlasherConfig & DataStoreConfig & {
+        ethereumSlotDuration: number;
+    }, rollup: RollupContract, l1Client: ViemClient, watchers: Watcher[], epochCache: EpochCache, dateProvider: DateProvider, kvStore: AztecLMDBStoreV2, rollupRegisteredAtL2Slot: SlotNumber, ownValidators?: EthAddress[], logger?: import("@aztec-labs/foundation/log").Logger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getConfig(): SlasherConfig;
+    updateConfig(config: Partial<SlasherConfig>): void;
+    gatherOffensesForRound(round?: bigint): Promise<Offense[]>;
+    getOffenses(): Promise<Offense[]>;
+    getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
+    private createSlasherClient;
+    private handleSlasherChange;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/slasher_client_facade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slasher_client_facade.d.ts","sourceRoot":"","sources":["../src/slasher_client_facade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAGhF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,mBAAoB,YAAW,sBAAsB;IAK9D,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,wBAAwB;IAChC,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,MAAM;IAbhB,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,OAAO,CAA2B;IAE1C,YACU,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG;QAAE,oBAAoB,EAAE,MAAM,CAAA;KAAE,EAC1E,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,gBAAgB,EACzB,wBAAwB,EAAE,UAAU,EACpC,aAAa,GAAE,UAAU,EAAO,EAChC,MAAM,8CAA0B,EACtC;IAES,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CASlC;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAIjC;IAEM,SAAS,IAAI,aAAa,CAEhC;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAIxD;IAEM,sBAAsB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAEhE;IAEM,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAEvC;IAEM,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAEhF;IAED,OAAO,CAAC,mBAAmB;YAeb,mBAAmB;CAMlC"}