@aztec/slasher 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/dest/stores/payloads_store.js

@@ -1,128 +0,0 @@
-import { deserializeSlashPayload, serializeSlashPayload } from '@aztec/stdlib/slashing';
-export class SlasherPayloadsStore {
-    kvStore;
-    settings;
-    /** Map from payload address to payload data */ payloads;
-    /** Map from `round:payload` to votes */ roundPayloadVotes;
-    constructor(kvStore, settings){
-        this.kvStore = kvStore;
-        this.settings = settings;
-        this.payloads = kvStore.openMap('slash-payloads');
-        this.roundPayloadVotes = kvStore.openMap('round-payload-votes');
-    }
-    async getPayloadsForRound(round) {
-        const payloads = [];
-        const votes = await this.getVotesForRound(round);
-        for (const [address, votesCount] of votes){
-            const payload = await this.getPayload(address);
-            if (payload) {
-                payloads.push({
-                    ...payload,
-                    votes: votesCount,
-                    round
-                });
-            }
-        }
-        return payloads;
-    }
-    async getPayloadAtRound(payloadAddress, round) {
-        const address = payloadAddress.toString();
-        const buffer = await this.payloads.getAsync(address);
-        if (!buffer) {
-            return undefined;
-        }
-        const data = deserializeSlashPayload(buffer);
-        const votes = await this.roundPayloadVotes.getAsync(this.getPayloadVotesKey(round, address)) ?? 0n;
-        return {
-            ...data,
-            votes,
-            round
-        };
-    }
-    async getVotesForRound(round) {
-        const votes = [];
-        for await (const [fullKey, roundVotes] of this.roundPayloadVotes.entriesAsync(this.getPayloadVotesKeyRangeForRound(round))){
-            // Extract just the address part from the key (remove "round:" prefix)
-            const address = fullKey.split(':')[1];
-            votes.push([
-                address,
-                roundVotes
-            ]);
-        }
-        return votes;
-    }
-    getRoundKey(round) {
-        return round.toString().padStart(16, '0');
-    }
-    getPayloadVotesKey(round, payloadAddress) {
-        return `${this.getRoundKey(round)}:${payloadAddress.toString()}`;
-    }
-    getPayloadVotesKeyRangeForRound(round) {
-        const start = `${this.getRoundKey(round)}:`;
-        const end = `${this.getRoundKey(round)}:Z`; // 'Z' sorts after any hex address, 0x-prefixed or not
-        return {
-            start,
-            end
-        };
-    }
-    /**
-   * Purge vote payload data for expired rounds. Does not delete actual payload data.
-   */ async clearExpiredPayloads(currentRound) {
-        const lifetimeInRounds = this.settings?.slashingPayloadLifetimeInRounds ?? 0;
-        if (lifetimeInRounds <= 0) {
-            return; // No lifetime configured
-        }
-        const expiredBefore = currentRound - BigInt(lifetimeInRounds);
-        if (expiredBefore < 0) {
-            return; // Not enough rounds have passed to expire anything
-        }
-        // Collect expired payload votes by scanning round-payload keys
-        const expiredPayloads = [];
-        const expiredVoteKeys = [];
-        for await (const key of this.roundPayloadVotes.keysAsync({
-            end: `${this.getRoundKey(expiredBefore)}:Z`
-        })){
-            const [roundStr, payloadAddress] = key.split(':');
-            if (BigInt(roundStr) <= expiredBefore) {
-                expiredVoteKeys.push(key);
-                expiredPayloads.push(payloadAddress);
-            }
-        }
-        if (expiredVoteKeys.length === 0) {
-            return; // No expired payloads to clean up
-        }
-        // Remove expired payload vote records
-        // Note that we do not delete payload data since these could be repurposed in future votes
-        await this.kvStore.transactionAsync(async ()=>{
-            for (const key of expiredVoteKeys){
-                await this.roundPayloadVotes.delete(key);
-            }
-        });
-    }
-    async incrementPayloadVotes(payloadAddress, round) {
-        const key = this.getPayloadVotesKey(round, payloadAddress);
-        let newVotes;
-        await this.kvStore.transactionAsync(async ()=>{
-            const currentVotes = await this.roundPayloadVotes.getAsync(key) || 0n;
-            newVotes = currentVotes + 1n;
-            await this.roundPayloadVotes.set(key, newVotes);
-        });
-        return newVotes;
-    }
-    async addPayload(payload) {
-        const address = payload.address.toString();
-        await this.kvStore.transactionAsync(async ()=>{
-            await this.payloads.set(address, serializeSlashPayload(payload));
-            await this.roundPayloadVotes.set(this.getPayloadVotesKey(payload.round, address), payload.votes);
-        });
-    }
-    async getPayload(payloadAddress) {
-        const address = payloadAddress.toString();
-        const buffer = await this.payloads.getAsync(address);
-        return buffer ? deserializeSlashPayload(buffer) : undefined;
-    }
-    async hasPayload(payload) {
-        const address = payload.toString();
-        return await this.payloads.getAsync(address) !== undefined;
-    }
-}

package/dest/tally_slasher_client.d.ts

@@ -1,125 +0,0 @@
-import type { EpochCache } from '@aztec/epoch-cache';
-import { RollupContract, SlasherContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import type { DateProvider } from '@aztec/foundation/timer';
-import type { Prettify } from '@aztec/foundation/types';
-import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
-import { type Offense, type ProposerSlashAction, type ProposerSlashActionProvider, type SlashPayloadRound } from '@aztec/stdlib/slashing';
-import type { Hex } from 'viem';
-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 tally slasher client, loaded from the L1 contracts during initialization */
-export type TallySlasherSettings = 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 TallySlasherClientConfig = SlashOffensesCollectorConfig & Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack'>;
-/**
- * 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 declare class TallySlasherClient implements ProposerSlashActionProvider, SlasherClientInterface {
-    private config;
-    private settings;
-    private tallySlashingProposer;
-    private slasher;
-    private rollup;
-    private epochCache;
-    private dateProvider;
-    private offensesStore;
-    private log;
-    protected unwatchCallbacks: (() => void)[];
-    protected roundMonitor: SlashRoundMonitor;
-    protected offensesCollector: SlashOffensesCollector;
-    constructor(config: TallySlasherClientConfig, settings: TallySlasherSettings, tallySlashingProposer: TallySlashingProposerContract, slasher: SlasherContract, rollup: RollupContract, watchers: Watcher[], epochCache: EpochCache, dateProvider: DateProvider, offensesStore: SlasherOffensesStore, log?: import("@aztec/foundation/log").Logger);
-    start(): Promise<void>;
-    /**
-     * Stop the tally 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 TallySlashingProposer (just for logging). */
-    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;
-    /**
-     * Get slash payloads is NOT SUPPORTED in tally model
-     * @throws Error indicating this operation is not supported
-     */
-    getSlashPayloads(): Promise<SlashPayloadRound[]>;
-    /**
-     * 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
-     */
-    gatherOffensesForRound(round?: bigint): Promise<Offense[]>;
-    /** Returns all pending offenses stored */
-    getPendingOffenses(): 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/tally_slasher_client.d.ts.map

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

package/dest/watchers/epoch_prune_watcher.d.ts

@@ -1,38 +0,0 @@
-import { EpochCache } from '@aztec/epoch-cache';
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import { L2Block, type L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
-import type { ICheckpointsBuilder, 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 checkpointsBuilder;
-    private log;
-    private boundHandlePruneL2Blocks;
-    private penalties;
-    constructor(l2BlockSource: L2BlockSourceEventEmitter, l1ToL2MessageSource: L1ToL2MessageSource, epochCache: EpochCache, txProvider: Pick<ITxProvider, 'getAvailableTxs'>, checkpointsBuilder: ICheckpointsBuilder, 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, previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations): Promise<void>;
-    private getValidatorsForEpoch;
-    private validatorsToSlashingArgs;
-}
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2hfcHJ1bmVfd2F0Y2hlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dhdGNoZXJzL2Vwb2NoX3BydW5lX3dhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBR2hELE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sRUFFTCxPQUFPLEVBQ1AsS0FBSyx5QkFBeUIsRUFHL0IsTUFBTSxxQkFBcUIsQ0FBQztBQUU3QixPQUFPLEtBQUssRUFDVixtQkFBbUIsRUFDbkIsV0FBVyxFQUNYLHlCQUF5QixFQUN6QixhQUFhLEVBQ2QsTUFBTSxpQ0FBaUMsQ0FBQztBQUN6QyxPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBNEIsTUFBTSx5QkFBeUIsQ0FBQztBQVk3RixPQUFPLEVBQTZDLEtBQUssT0FBTyxFQUFFLEtBQUssY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTdHLFFBQUEsTUFBTSxvQ0FBb0MsK0RBQWdFLENBQUM7QUFFM0csS0FBSywwQkFBMEIsR0FBRyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUMsT0FBTyxvQ0FBb0MsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7O0FBRTdHOzs7OztHQUtHO0FBQ0gscUJBQWEsaUJBQWtCLFNBQVEsc0JBQTJDLFlBQVcsT0FBTztJQVNoRyxPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsbUJBQW1CO0lBQzNCLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxrQkFBa0I7SUFaNUIsT0FBTyxDQUFDLEdBQUcsQ0FBK0M7SUFHMUQsT0FBTyxDQUFDLHdCQUF3QixDQUF1QztJQUV2RSxPQUFPLENBQUMsU0FBUyxDQUE2QjtJQUU5QyxZQUNVLGFBQWEsRUFBRSx5QkFBeUIsRUFDeEMsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQ3hDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFVBQVUsRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLGlCQUFpQixDQUFDLEVBQ2hELGtCQUFrQixFQUFFLG1CQUFtQixFQUMvQyxTQUFTLEVBQUUsMEJBQTBCLEVBT3RDO0lBRU0sS0FBSyxrQkFHWDtJQUVNLElBQUksa0JBR1Y7SUFFTSxZQUFZLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxhQUFhLENBQUMsR0FBRyxJQUFJLENBR3hEO0lBRUQsT0FBTyxDQUFDLG1CQUFtQjtZQU9iLGlCQUFpQjtZQVdqQixvQkFBb0I7SUF3QnJCLGNBQWMsQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWtCNUQ7SUFFWSxhQUFhLENBQ3hCLFdBQVcsRUFBRSxPQUFPLEVBQ3BCLDJCQUEyQixFQUFFLEVBQUUsRUFBRSxFQUNqQyxJQUFJLEVBQUUseUJBQXlCLEdBQzlCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E4Q2Y7WUFFYSxxQkFBcUI7SUFTbkMsT0FBTyxDQUFDLHdCQUF3QjtDQWdCakMifQ==

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

@@ -1 +0,0 @@
-{"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,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,EAEL,OAAO,EACP,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,mBAAmB,EACnB,WAAW,EACX,yBAAyB,EACzB,aAAa,EACd,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,mBAAmB,EAA4B,MAAM,yBAAyB,CAAC;AAY7F,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;;AAE7G;;;;;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,kBAAkB;IAZ5B,OAAO,CAAC,GAAG,CAA+C;IAG1D,OAAO,CAAC,wBAAwB,CAAuC;IAEvE,OAAO,CAAC,SAAS,CAA6B;IAE9C,YACU,aAAa,EAAE,yBAAyB,EACxC,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,iBAAiB,CAAC,EAChD,kBAAkB,EAAE,mBAAmB,EAC/C,SAAS,EAAE,0BAA0B,EAOtC;IAEM,KAAK,kBAGX;IAEM,IAAI,kBAGV;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAGxD;IAED,OAAO,CAAC,mBAAmB;YAOb,iBAAiB;YAWjB,oBAAoB;IAwBrB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB5D;IAEY,aAAa,CACxB,WAAW,EAAE,OAAO,EACpB,2BAA2B,EAAE,EAAE,EAAE,EACjC,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA8Cf;YAEa,qBAAqB;IASnC,OAAO,CAAC,wBAAwB;CAgBjC"}

package/dest/watchers/epoch_prune_watcher.js

@@ -1,158 +0,0 @@
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { merge, pick } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
-import { L2BlockSourceEvents } from '@aztec/stdlib/block';
-import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
-import { computeCheckpointOutHash } from '@aztec/stdlib/messaging';
-import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
-import { ReExFailedTxsError, ReExStateMismatchError, TransactionsNotAvailableError, ValidatorError } from '@aztec/stdlib/validators';
-import EventEmitter from 'node:events';
-import { WANT_TO_SLASH_EVENT } from '../watcher.js';
-const EpochPruneWatcherPenaltiesConfigKeys = [
-    'slashPrunePenalty',
-    'slashDataWithholdingPenalty'
-];
-/**
- * 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 class EpochPruneWatcher extends EventEmitter {
-    l2BlockSource;
-    l1ToL2MessageSource;
-    epochCache;
-    txProvider;
-    checkpointsBuilder;
-    log;
-    // Store bound function reference for proper listener removal
-    boundHandlePruneL2Blocks;
-    penalties;
-    constructor(l2BlockSource, l1ToL2MessageSource, epochCache, txProvider, checkpointsBuilder, penalties){
-        super(), this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.epochCache = epochCache, this.txProvider = txProvider, this.checkpointsBuilder = checkpointsBuilder, this.log = createLogger('epoch-prune-watcher'), this.boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
-        this.penalties = pick(penalties, ...EpochPruneWatcherPenaltiesConfigKeys);
-        this.log.verbose(`EpochPruneWatcher initialized with penalties: valid epoch pruned=${penalties.slashPrunePenalty} data withholding=${penalties.slashDataWithholdingPenalty}`);
-    }
-    start() {
-        this.l2BlockSource.events.on(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
-        return Promise.resolve();
-    }
-    stop() {
-        this.l2BlockSource.events.removeListener(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
-        return Promise.resolve();
-    }
-    updateConfig(config) {
-        this.penalties = merge(this.penalties, pick(config, ...EpochPruneWatcherPenaltiesConfigKeys));
-        this.log.verbose('EpochPruneWatcher config updated', this.penalties);
-    }
-    handlePruneL2Blocks(event) {
-        const { blocks, epochNumber } = event;
-        void this.processPruneL2Blocks(blocks, epochNumber).catch((err)=>this.log.error('Error processing pruned L2 blocks', err, {
-                epochNumber
-            }));
-    }
-    async emitSlashForEpoch(offense, epochNumber) {
-        const validators = await this.getValidatorsForEpoch(epochNumber);
-        if (validators.length === 0) {
-            this.log.warn(`No validators found for epoch ${epochNumber} (cannot slash for ${getOffenseTypeName(offense)})`);
-            return;
-        }
-        const args = this.validatorsToSlashingArgs(validators, offense, epochNumber);
-        this.log.verbose(`Created slash for ${getOffenseTypeName(offense)} at epoch ${epochNumber}`, args);
-        this.emit(WANT_TO_SLASH_EVENT, args);
-    }
-    async processPruneL2Blocks(blocks, epochNumber) {
-        try {
-            const l1Constants = this.epochCache.getL1Constants();
-            const epochBlocks = blocks.filter((b)=>getEpochAtSlot(b.header.getSlot(), l1Constants) === epochNumber);
-            this.log.info(`Detected chain prune. Validating epoch ${epochNumber} with blocks ${epochBlocks[0]?.number} to ${epochBlocks[epochBlocks.length - 1]?.number}.`, {
-                blocks: epochBlocks.map((b)=>b.toBlockInfo())
-            });
-            await this.validateBlocks(epochBlocks);
-            this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
-            await this.emitSlashForEpoch(OffenseType.VALID_EPOCH_PRUNED, epochNumber);
-        } catch (error) {
-            if (error instanceof TransactionsNotAvailableError) {
-                this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, {
-                    message: error.message
-                });
-                await this.emitSlashForEpoch(OffenseType.DATA_WITHHOLDING, epochNumber);
-            } else {
-                this.log.error(`Error while validating pruned epoch ${epochNumber}. Will not want to slash.`, error);
-            }
-        }
-    }
-    async validateBlocks(blocks) {
-        if (blocks.length === 0) {
-            return;
-        }
-        let previousCheckpointOutHashes = [];
-        const fork = await this.checkpointsBuilder.getFork(BlockNumber(blocks[0].header.globalVariables.blockNumber - 1));
-        try {
-            for (const block of blocks){
-                await this.validateBlock(block, previousCheckpointOutHashes, fork);
-                // TODO(mbps): This assumes one block per checkpoint, which is only true for now.
-                const checkpointOutHash = computeCheckpointOutHash([
-                    block.body.txEffects.map((tx)=>tx.l2ToL1Msgs)
-                ]);
-                previousCheckpointOutHashes = [
-                    ...previousCheckpointOutHashes,
-                    checkpointOutHash
-                ];
-            }
-        } finally{
-            await fork.close();
-        }
-    }
-    async validateBlock(blockFromL1, previousCheckpointOutHashes, fork) {
-        this.log.debug(`Validating pruned block ${blockFromL1.header.globalVariables.blockNumber}`);
-        const txHashes = blockFromL1.body.txEffects.map((txEffect)=>txEffect.txHash);
-        // We load txs from the mempool directly, since the TxCollector running in the background has already been
-        // trying to fetch them from nodes or via reqresp. If we haven't managed to collect them by now,
-        // it's likely that they are not available in the network at all.
-        const { txs, missingTxs } = await this.txProvider.getAvailableTxs(txHashes);
-        if (missingTxs && missingTxs.length > 0) {
-            throw new TransactionsNotAvailableError(missingTxs);
-        }
-        const checkpointNumber = CheckpointNumber.fromBlockNumber(blockFromL1.number);
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
-        const gv = blockFromL1.header.globalVariables;
-        const constants = {
-            chainId: gv.chainId,
-            version: gv.version,
-            slotNumber: gv.slotNumber,
-            coinbase: gv.coinbase,
-            feeRecipient: gv.feeRecipient,
-            gasFees: gv.gasFees
-        };
-        // Use checkpoint builder to validate the block
-        const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork, this.log.getBindings());
-        const { block, failedTxs, numTxs } = await checkpointBuilder.buildBlock(txs, gv.blockNumber, gv.timestamp, {});
-        if (numTxs !== txs.length) {
-            // This should be detected by state mismatch, but this makes it easier to debug.
-            throw new ValidatorError(`Built block with ${numTxs} txs, expected ${txs.length}`);
-        }
-        if (failedTxs.length > 0) {
-            throw new ReExFailedTxsError(failedTxs.length);
-        }
-        if (!block.archive.root.equals(blockFromL1.archive.root)) {
-            throw new ReExStateMismatchError(blockFromL1.archive.root, block.archive.root);
-        }
-    }
-    async getValidatorsForEpoch(epochNumber) {
-        const { committee } = await this.epochCache.getCommitteeForEpoch(epochNumber);
-        if (!committee) {
-            this.log.trace(`No committee found for epoch ${epochNumber}`);
-            return [];
-        }
-        return committee;
-    }
-    validatorsToSlashingArgs(validators, offenseType, epochOrSlot) {
-        const penalty = offenseType === OffenseType.DATA_WITHHOLDING ? this.penalties.slashDataWithholdingPenalty : this.penalties.slashPrunePenalty;
-        return validators.map((v)=>({
-                validator: v,
-                amount: penalty,
-                offenseType,
-                epochOrSlot: BigInt(epochOrSlot)
-            }));
-    }
-}