@aztec/slasher 0.0.1-commit.24de95ac

package/dest/tally_slasher_client.js

@@ -0,0 +1,349 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { maxBigint } from '@aztec/foundation/bigint';
+import { compactArray, partition, times } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { OffenseType, getEpochsForRound, getSlashConsensusVotesFromOffenses } from '@aztec/stdlib/slashing';
+import { SlashOffensesCollector } from './slash_offenses_collector.js';
+import { SlashRoundMonitor } from './slash_round_monitor.js';
+/**
+ * The Tally 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.
+ *
+ * Differences from Empire model
+ * - No fixed slash payloads - votes are for individual validator offenses encoded in bytes
+ * - The L1 contract determines which offenses reach quorum rather than nodes agreeing on a payload
+ * - Proposers vote directly on which validators to slash and by how much
+ * - Uses a slash offset to vote on validators from past rounds (e.g., round N votes on round N-2)
+ */ export class TallySlasherClient {
+    config;
+    settings;
+    tallySlashingProposer;
+    slasher;
+    rollup;
+    epochCache;
+    dateProvider;
+    offensesStore;
+    log;
+    unwatchCallbacks;
+    roundMonitor;
+    offensesCollector;
+    constructor(config, settings, tallySlashingProposer, slasher, rollup, watchers, epochCache, dateProvider, offensesStore, log = createLogger('slasher:consensus')){
+        this.config = config;
+        this.settings = settings;
+        this.tallySlashingProposer = tallySlashingProposer;
+        this.slasher = slasher;
+        this.rollup = rollup;
+        this.epochCache = epochCache;
+        this.dateProvider = dateProvider;
+        this.offensesStore = offensesStore;
+        this.log = log;
+        this.unwatchCallbacks = [];
+        this.roundMonitor = new SlashRoundMonitor(settings, dateProvider);
+        this.offensesCollector = new SlashOffensesCollector(config, settings, watchers, offensesStore);
+    }
+    async start() {
+        this.log.debug('Starting Tally Slasher client...');
+        this.roundMonitor.start();
+        await this.offensesCollector.start();
+        // Listen for RoundExecuted events
+        this.unwatchCallbacks.push(this.tallySlashingProposer.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)));
+        this.log.info(`Started tally slasher client`);
+        return Promise.resolve();
+    }
+    /**
+   * Stop the tally slasher client
+   */ async stop() {
+        this.log.debug('Stopping Tally Slasher client...');
+        for (const unwatchCallback of this.unwatchCallbacks){
+            unwatchCallback();
+        }
+        this.roundMonitor.stop();
+        await this.offensesCollector.stop();
+        // Sleeping to sidestep viem issue with unwatching events
+        await sleep(2000);
+        this.log.info('Tally 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 tally slashing round ${round}`);
+        await this.offensesCollector.handleNewRound(round);
+    }
+    /** Called when we see a RoundExecuted event on the TallySlashingProposer (just for logging). */ async handleRoundExecuted(round, slashCount, l1BlockHash) {
+        const slashes = await this.rollup.getSlashEvents(l1BlockHash);
+        this.log.info(`Slashing round ${round} has been executed with ${slashCount} slashes`, {
+            slashes
+        });
+    }
+    /**
+   * 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.tallySlashingProposer.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.tallySlashingProposer.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.tallySlashingProposer.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.tallySlashingProposer.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;
+            }
+            this.log.info(`Round ${executableRound} is ready to execute with ${slashActions.length} slashes`, {
+                slashActions,
+                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,
+                offensesToForgive,
+                slashValidatorsAlways: this.config.slashValidatorsAlways
+            });
+        }
+        if (offensesToForgive.length > 0) {
+            this.log.verbose(`Skipping slashing of ${offensesToForgive.length} offenses`, {
+                slotNumber,
+                currentRound,
+                slashedRound,
+                offensesToForgive,
+                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.info(`Voting to slash ${offensesToSlash.length} offenses`, {
+            slotNumber,
+            currentRound,
+            slashedRound,
+            offensesToSlash
+        });
+        const committees = await this.collectCommitteesActiveDuringRound(slashedRound);
+        const epochsForCommittees = getEpochsForRound(slashedRound, this.settings);
+        const votes = getSlashConsensusVotesFromOffenses(offensesToSlash, committees, epochsForCommittees, this.settings);
+        if (votes.every((v)=>v === 0)) {
+            this.log.warn(`Computed votes for offenses are all zero. Skipping vote.`, {
+                slotNumber,
+                currentRound,
+                slashedRound,
+                offensesToSlash,
+                committees
+            });
+            return undefined;
+        }
+        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)));
+    }
+    /**
+   * Get slash payloads is NOT SUPPORTED in tally model
+   * @throws Error indicating this operation is not supported
+   */ getSlashPayloads() {
+        return Promise.reject(new Error('Tally slashing model does not support slash payloads'));
+    }
+    /**
+   * Gather offenses to be slashed on a given round.
+   * In tally slashing, 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 pending offenses stored */ getPendingOffenses() {
+        return this.offensesStore.getPendingOffenses();
+    }
+    /**
+   * 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);
+    }
+}

package/dest/test/dummy_watcher.d.ts

@@ -0,0 +1,11 @@
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import { type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
+declare const DummyWatcher_base: new () => WatcherEmitter;
+export declare class DummyWatcher extends DummyWatcher_base implements Watcher {
+    updateConfig(_config: Partial<SlasherConfig>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    triggerSlash(args: WantToSlashArgs[]): void;
+}
+export {};
+//# sourceMappingURL=dummy_watcher.d.ts.map

package/dest/test/dummy_watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dummy_watcher.d.ts","sourceRoot":"","sources":["../../src/test/dummy_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAIrE,OAAO,EAAuB,KAAK,eAAe,EAAE,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;iCAE1D,UAAU,cAAc;AAA3E,qBAAa,YAAa,SAAQ,iBAA2C,YAAW,OAAO;IACtF,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;IAE5C,KAAK;IAIL,IAAI;IAIJ,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE;CAG5C"}

package/dest/test/dummy_watcher.js

@@ -0,0 +1,14 @@
+import EventEmitter from 'node:events';
+import { WANT_TO_SLASH_EVENT } from '../watcher.js';
+export class DummyWatcher extends EventEmitter {
+    updateConfig(_config) {}
+    start() {
+        return Promise.resolve();
+    }
+    stop() {
+        return Promise.resolve();
+    }
+    triggerSlash(args) {
+        this.emit(WANT_TO_SLASH_EVENT, args);
+    }
+}

package/dest/watcher.d.ts

@@ -0,0 +1,21 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
+import { OffenseType } from '@aztec/stdlib/slashing';
+import type { SlasherConfig } from './config.js';
+export declare const WANT_TO_SLASH_EVENT: "want-to-slash";
+export interface WantToSlashArgs {
+    validator: EthAddress;
+    amount: bigint;
+    offenseType: OffenseType;
+    epochOrSlot: bigint;
+}
+export interface WatcherEventMap {
+    [WANT_TO_SLASH_EVENT]: (args: WantToSlashArgs[]) => void;
+}
+export type WatcherEmitter = TypedEventEmitter<WatcherEventMap>;
+export type Watcher = WatcherEmitter & {
+    start?: () => Promise<void>;
+    stop?: () => Promise<void>;
+    updateConfig: (config: Partial<SlasherConfig>) => void;
+};
+//# sourceMappingURL=watcher.d.ts.map

package/dest/watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../src/watcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,eAAO,MAAM,mBAAmB,EAAG,eAAwB,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,UAAU,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,eAAe;IAC9B,CAAC,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CAC1D;AAED,MAAM,MAAM,cAAc,GAAG,iBAAiB,CAAC,eAAe,CAAC,CAAC;AAEhE,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG;IACrC,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,YAAY,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC;CACxD,CAAC"}

package/dest/watcher.js

@@ -0,0 +1 @@
+export const WANT_TO_SLASH_EVENT = 'want-to-slash';

package/dest/watchers/attestations_block_watcher.d.ts

@@ -0,0 +1,33 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import { type L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
+import type { SlasherConfig } from '../config.js';
+import { type Watcher, type WatcherEmitter } from '../watcher.js';
+declare const AttestationsBlockWatcherConfigKeys: readonly ["slashAttestDescendantOfInvalidPenalty", "slashProposeInvalidAttestationsPenalty"];
+type AttestationsBlockWatcherConfig = Pick<SlasherConfig, (typeof AttestationsBlockWatcherConfigKeys)[number]>;
+declare const AttestationsBlockWatcher_base: new () => WatcherEmitter;
+/**
+ * This watcher is responsible for detecting invalid blocks and creating slashing arguments for offenders.
+ * An invalid block is one that doesn't have enough attestations or has incorrect attestations.
+ * The proposer of an invalid block should be slashed.
+ * If there's another block consecutive to the invalid one, its proposer and attestors should also be slashed.
+ */
+export declare class AttestationsBlockWatcher extends AttestationsBlockWatcher_base implements Watcher {
+    private l2BlockSource;
+    private epochCache;
+    private log;
+    private maxInvalidBlocks;
+    private invalidArchiveRoots;
+    private config;
+    private boundHandleInvalidBlock;
+    constructor(l2BlockSource: L2BlockSourceEventEmitter, epochCache: EpochCache, config: AttestationsBlockWatcherConfig);
+    updateConfig(newConfig: Partial<AttestationsBlockWatcherConfig>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleInvalidBlock;
+    private slashAttestorsOnAncestorInvalid;
+    private slashProposer;
+    private getOffenseFromInvalidationReason;
+    private addInvalidBlock;
+}
+export {};
+//# sourceMappingURL=attestations_block_watcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attestations_block_watcher.d.ts","sourceRoot":"","sources":["../../src/watchers/attestations_block_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,EAGL,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAC;AAK7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAA6C,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7G,QAAA,MAAM,kCAAkC,8FAG9B,CAAC;AAEX,KAAK,8BAA8B,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,kCAAkC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;6CAQhD,UAAU,cAAc;AANvF;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,6BAA2C,YAAW,OAAO;IAuBvG,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,UAAU;IAvBpB,OAAO,CAAC,GAAG,CAAsD;IAGjE,OAAO,CAAC,gBAAgB,CAAO;IAG/B,OAAO,CAAC,mBAAmB,CAA0B;IAErD,OAAO,CAAC,MAAM,CAAiC;IAE/C,OAAO,CAAC,uBAAuB,CAS7B;gBAGQ,aAAa,EAAE,yBAAyB,EACxC,UAAU,EAAE,UAAU,EAC9B,MAAM,EAAE,8BAA8B;IAOjC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,8BAA8B,CAAC;IAK/D,KAAK;IAKL,IAAI;IAQX,OAAO,CAAC,kBAAkB;IAyB1B,OAAO,CAAC,+BAA+B;IAwBvC,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,gCAAgC;IAaxC,OAAO,CAAC,eAAe;CASxB"}

package/dest/watchers/attestations_block_watcher.js

@@ -0,0 +1,135 @@
+import { merge, pick } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { L2BlockSourceEvents } from '@aztec/stdlib/block';
+import { OffenseType } from '@aztec/stdlib/slashing';
+import EventEmitter from 'node:events';
+import { WANT_TO_SLASH_EVENT } from '../watcher.js';
+const AttestationsBlockWatcherConfigKeys = [
+    'slashAttestDescendantOfInvalidPenalty',
+    'slashProposeInvalidAttestationsPenalty'
+];
+/**
+ * This watcher is responsible for detecting invalid blocks and creating slashing arguments for offenders.
+ * An invalid block is one that doesn't have enough attestations or has incorrect attestations.
+ * The proposer of an invalid block should be slashed.
+ * If there's another block consecutive to the invalid one, its proposer and attestors should also be slashed.
+ */ export class AttestationsBlockWatcher extends EventEmitter {
+    l2BlockSource;
+    epochCache;
+    log;
+    // Only keep track of the last N invalid blocks
+    maxInvalidBlocks;
+    // All invalid archive roots seen
+    invalidArchiveRoots;
+    config;
+    boundHandleInvalidBlock;
+    constructor(l2BlockSource, epochCache, config){
+        super(), this.l2BlockSource = l2BlockSource, this.epochCache = epochCache, this.log = createLogger('attestations-block-watcher'), this.maxInvalidBlocks = 100, this.invalidArchiveRoots = new Set(), this.boundHandleInvalidBlock = (event)=>{
+            try {
+                this.handleInvalidBlock(event);
+            } catch (err) {
+                this.log.error('Error handling invalid block', err, {
+                    ...event.validationResult,
+                    reason: event.validationResult.reason
+                });
+            }
+        };
+        this.config = pick(config, ...AttestationsBlockWatcherConfigKeys);
+        this.log.info('AttestationsBlockWatcher initialized');
+    }
+    updateConfig(newConfig) {
+        this.config = merge(this.config, pick(newConfig, ...AttestationsBlockWatcherConfigKeys));
+        this.log.verbose('AttestationsBlockWatcher config updated', this.config);
+    }
+    start() {
+        this.l2BlockSource.on(L2BlockSourceEvents.InvalidAttestationsBlockDetected, this.boundHandleInvalidBlock);
+        return Promise.resolve();
+    }
+    stop() {
+        this.l2BlockSource.removeListener(L2BlockSourceEvents.InvalidAttestationsBlockDetected, this.boundHandleInvalidBlock);
+        return Promise.resolve();
+    }
+    handleInvalidBlock(event) {
+        const { validationResult } = event;
+        const block = validationResult.block;
+        // Check if we already have processed this block, archiver may emit the same event multiple times
+        if (this.invalidArchiveRoots.has(block.archive.toString())) {
+            this.log.trace(`Already processed invalid block ${block.blockNumber}`);
+            return;
+        }
+        this.log.verbose(`Detected invalid block ${block.blockNumber}`, {
+            ...block,
+            reason: validationResult.valid === false ? validationResult.reason : 'unknown'
+        });
+        // Store the invalid block
+        this.addInvalidBlock(event.validationResult.block);
+        // Slash the proposer of the invalid block
+        this.slashProposer(event.validationResult);
+        // Check if the parent of this block is invalid as well, if so, we will slash its attestors as well
+        this.slashAttestorsOnAncestorInvalid(event.validationResult);
+    }
+    slashAttestorsOnAncestorInvalid(validationResult) {
+        const block = validationResult.block;
+        const parentArchive = block.lastArchive.toString();
+        if (this.invalidArchiveRoots.has(parentArchive)) {
+            const attestors = validationResult.attestors;
+            this.log.info(`Want to slash attestors of block ${block.blockNumber} built on invalid block`, {
+                ...block,
+                ...attestors,
+                parentArchive
+            });
+            this.emit(WANT_TO_SLASH_EVENT, attestors.map((attestor)=>({
+                    validator: attestor,
+                    amount: this.config.slashAttestDescendantOfInvalidPenalty,
+                    offenseType: OffenseType.ATTESTED_DESCENDANT_OF_INVALID,
+                    epochOrSlot: BigInt(block.slotNumber)
+                })));
+        }
+    }
+    slashProposer(validationResult) {
+        const { reason, block } = validationResult;
+        const blockNumber = block.blockNumber;
+        const slot = BigInt(block.slotNumber);
+        const proposer = this.epochCache.getProposerFromEpochCommittee(validationResult, slot);
+        if (!proposer) {
+            this.log.warn(`No proposer found for block ${blockNumber} at slot ${slot}`);
+            return;
+        }
+        const offense = this.getOffenseFromInvalidationReason(reason);
+        const amount = this.config.slashProposeInvalidAttestationsPenalty;
+        const args = {
+            validator: proposer,
+            amount,
+            offenseType: offense,
+            epochOrSlot: slot
+        };
+        this.log.info(`Want to slash proposer of block ${blockNumber} due to ${reason}`, {
+            ...block,
+            ...args
+        });
+        this.emit(WANT_TO_SLASH_EVENT, [
+            args
+        ]);
+    }
+    getOffenseFromInvalidationReason(reason) {
+        switch(reason){
+            case 'invalid-attestation':
+                return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
+            case 'insufficient-attestations':
+                return OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS;
+            default:
+                {
+                    const _ = reason;
+                    return OffenseType.UNKNOWN;
+                }
+        }
+    }
+    addInvalidBlock(block) {
+        this.invalidArchiveRoots.add(block.archive.toString());
+        // Prune old entries if we exceed the maximum
+        if (this.invalidArchiveRoots.size > this.maxInvalidBlocks) {
+            const oldestKey = this.invalidArchiveRoots.keys().next().value;
+            this.invalidArchiveRoots.delete(oldestKey);
+        }
+    }
+}

package/dest/watchers/epoch_prune_watcher.d.ts

@@ -0,0 +1,37 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import { L2Block, type L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
+import type { IFullNodeBlockBuilder, ITxProvider, MerkleTreeWriteOperations, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { type Watcher, type WatcherEmitter } from '../watcher.js';
+declare const EpochPruneWatcherPenaltiesConfigKeys: readonly ["slashPrunePenalty", "slashDataWithholdingPenalty"];
+type EpochPruneWatcherPenalties = Pick<SlasherConfig, (typeof EpochPruneWatcherPenaltiesConfigKeys)[number]>;
+declare const EpochPruneWatcher_base: new () => WatcherEmitter;
+/**
+ * This watcher is responsible for detecting chain prunes and creating slashing arguments for the committee.
+ * It only wants to slash if:
+ * - the transactions are not available
+ * - OR the archive roots match when re-building all the blocks in the epoch (i.e. the epoch *could* have been proven)
+ */
+export declare class EpochPruneWatcher extends EpochPruneWatcher_base implements Watcher {
+    private l2BlockSource;
+    private l1ToL2MessageSource;
+    private epochCache;
+    private txProvider;
+    private blockBuilder;
+    private log;
+    private boundHandlePruneL2Blocks;
+    private penalties;
+    constructor(l2BlockSource: L2BlockSourceEventEmitter, l1ToL2MessageSource: L1ToL2MessageSource, epochCache: EpochCache, txProvider: Pick<ITxProvider, 'getAvailableTxs'>, blockBuilder: IFullNodeBlockBuilder, penalties: EpochPruneWatcherPenalties);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    updateConfig(config: Partial<SlasherConfig>): void;
+    private handlePruneL2Blocks;
+    private emitSlashForEpoch;
+    private processPruneL2Blocks;
+    validateBlocks(blocks: L2Block[]): Promise<void>;
+    validateBlock(blockFromL1: L2Block, fork: MerkleTreeWriteOperations): Promise<void>;
+    private getValidatorsForEpoch;
+    private validatorsToSlashingArgs;
+}
+export {};
+//# sourceMappingURL=epoch_prune_watcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"epoch_prune_watcher.d.ts","sourceRoot":"","sources":["../../src/watchers/epoch_prune_watcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,EAEL,OAAO,EAEP,KAAK,yBAAyB,EAE/B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,qBAAqB,EACrB,WAAW,EACX,yBAAyB,EACzB,aAAa,EACd,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAWnE,OAAO,EAA6C,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7G,QAAA,MAAM,oCAAoC,+DAAgE,CAAC;AAE3G,KAAK,0BAA0B,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,oCAAoC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;sCAQrD,UAAU,cAAc;AANhF;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,sBAA2C,YAAW,OAAO;IAShG,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,YAAY;IAZtB,OAAO,CAAC,GAAG,CAA+C;IAG1D,OAAO,CAAC,wBAAwB,CAAuC;IAEvE,OAAO,CAAC,SAAS,CAA6B;gBAGpC,aAAa,EAAE,yBAAyB,EACxC,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,iBAAiB,CAAC,EAChD,YAAY,EAAE,qBAAqB,EAC3C,SAAS,EAAE,0BAA0B;IAShC,KAAK;IAKL,IAAI;IAKJ,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI;IAKzD,OAAO,CAAC,mBAAmB;YAOb,iBAAiB;YAWjB,oBAAoB;IAwBrB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAchD,aAAa,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;YAgClF,qBAAqB;IASnC,OAAO,CAAC,wBAAwB;CAgBjC"}