@aztec/slasher 0.0.1-commit.0208eb9

package/dest/tally_slasher_client.js

@@ -0,0 +1,354 @@
+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 { 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();
+        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;
+            }
+            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,
+                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;
+        }
+        const offensesToSlashLog = offensesToSlash.map((offense)=>({
+                ...offense,
+                amount: offense.amount.toString()
+            }));
+        this.log.info(`Voting to slash ${offensesToSlash.length} offenses`, {
+            slotNumber,
+            currentRound,
+            slashedRound,
+            offensesToSlash: offensesToSlashLog
+        });
+        const committees = await this.collectCommitteesActiveDuringRound(slashedRound);
+        const epochsForCommittees = getEpochsForRound(slashedRound, this.settings);
+        const votes = getSlashConsensusVotesFromOffenses(offensesToSlash, committees, epochsForCommittees.map((e)=>BigInt(e)), 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHVtbXlfd2F0Y2hlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3QvZHVtbXlfd2F0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUlyRSxPQUFPLEVBQXVCLEtBQUssZUFBZSxFQUFFLEtBQUssT0FBTyxFQUFFLEtBQUssY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUU3RyxxQkFBYSxZQUFhLFNBQVEsaUJBQTJDLFlBQVcsT0FBTztJQUN0RixZQUFZLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxhQUFhLENBQUMsUUFBSTtJQUVoRCxLQUFLLGtCQUVYO0lBRU0sSUFBSSxrQkFFVjtJQUVNLFlBQVksQ0FBQyxJQUFJLEVBQUUsZUFBZSxFQUFFLFFBRTFDO0NBQ0YifQ==

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;;AAE7G,qBAAa,YAAa,SAAQ,iBAA2C,YAAW,OAAO;IACtF,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,QAAI;IAEhD,KAAK,kBAEX;IAEM,IAAI,kBAEV;IAEM,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE,QAE1C;CACF"}

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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2hlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3dhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDakUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXJELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUVqRCxlQUFPLE1BQU0sbUJBQW1CLGlCQUEyQixDQUFDO0FBRTVELE1BQU0sV0FBVyxlQUFlO0lBQzlCLFNBQVMsRUFBRSxVQUFVLENBQUM7SUFDdEIsTUFBTSxFQUFFLE1BQU0sQ0FBQztJQUNmLFdBQVcsRUFBRSxXQUFXLENBQUM7SUFDekIsV0FBVyxFQUFFLE1BQU0sQ0FBQztDQUNyQjtBQUdELE1BQU0sV0FBVyxlQUFlO0lBQzlCLENBQUMsbUJBQW1CLENBQUMsRUFBRSxDQUFDLElBQUksRUFBRSxlQUFlLEVBQUUsS0FBSyxJQUFJLENBQUM7Q0FDMUQ7QUFFRCxNQUFNLE1BQU0sY0FBYyxHQUFHLGlCQUFpQixDQUFDLGVBQWUsQ0FBQyxDQUFDO0FBRWhFLE1BQU0sTUFBTSxPQUFPLEdBQUcsY0FBYyxHQUFHO0lBQ3JDLEtBQUssQ0FBQyxFQUFFLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzVCLElBQUksQ0FBQyxFQUFFLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzNCLFlBQVksRUFBRSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsYUFBYSxDQUFDLEtBQUssSUFBSSxDQUFDO0NBQ3hELENBQUMifQ==

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,iBAA2B,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,34 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import { type InvalidCheckpointDetectedEvent, 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 maxInvalidCheckpoints;
+    private invalidArchiveRoots;
+    private config;
+    private boundHandleInvalidCheckpoint;
+    constructor(l2BlockSource: L2BlockSourceEventEmitter, epochCache: EpochCache, config: AttestationsBlockWatcherConfig);
+    updateConfig(newConfig: Partial<AttestationsBlockWatcherConfig>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Event handler for invalid checkpoints as reported by the archiver. Public for testing purposes. */
+    handleInvalidCheckpoint(event: InvalidCheckpointDetectedEvent): void;
+    private slashAttestorsOnAncestorInvalid;
+    private slashProposer;
+    private getOffenseFromInvalidationReason;
+    private addInvalidCheckpoint;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25zX2Jsb2NrX3dhdGNoZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93YXRjaGVycy9hdHRlc3RhdGlvbnNfYmxvY2tfd2F0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFJaEQsT0FBTyxFQUNMLEtBQUssOEJBQThCLEVBQ25DLEtBQUsseUJBQXlCLEVBRy9CLE1BQU0scUJBQXFCLENBQUM7QUFNN0IsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ2xELE9BQU8sRUFBNkMsS0FBSyxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFN0csUUFBQSxNQUFNLGtDQUFrQyw4RkFHOUIsQ0FBQztBQUVYLEtBQUssOEJBQThCLEdBQUcsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDLE9BQU8sa0NBQWtDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDOztBQUUvRzs7Ozs7R0FLRztBQUNILHFCQUFhLHdCQUF5QixTQUFRLDZCQUEyQyxZQUFXLE9BQU87SUF1QnZHLE9BQU8sQ0FBQyxhQUFhO0lBQ3JCLE9BQU8sQ0FBQyxVQUFVO0lBdkJwQixPQUFPLENBQUMsR0FBRyxDQUFzRDtJQUdqRSxPQUFPLENBQUMscUJBQXFCLENBQU87SUFHcEMsT0FBTyxDQUFDLG1CQUFtQixDQUEwQjtJQUVyRCxPQUFPLENBQUMsTUFBTSxDQUFpQztJQUUvQyxPQUFPLENBQUMsNEJBQTRCLENBU2xDO0lBRUYsWUFDVSxhQUFhLEVBQUUseUJBQXlCLEVBQ3hDLFVBQVUsRUFBRSxVQUFVLEVBQzlCLE1BQU0sRUFBRSw4QkFBOEIsRUFLdkM7SUFFTSxZQUFZLENBQUMsU0FBUyxFQUFFLE9BQU8sQ0FBQyw4QkFBOEIsQ0FBQyxRQUdyRTtJQUVNLEtBQUssa0JBTVg7SUFFTSxJQUFJLGtCQU1WO0lBRUQsc0dBQXNHO0lBQy9GLHVCQUF1QixDQUFDLEtBQUssRUFBRSw4QkFBOEIsR0FBRyxJQUFJLENBdUIxRTtJQUVELE9BQU8sQ0FBQywrQkFBK0I7SUEyQnZDLE9BQU8sQ0FBQyxhQUFhO0lBa0NyQixPQUFPLENBQUMsZ0NBQWdDO0lBYXhDLE9BQU8sQ0FBQyxvQkFBb0I7Q0FTN0IifQ==

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;AAIhD,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAC;AAM7B,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;;AAE/G;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,6BAA2C,YAAW,OAAO;IAuBvG,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,UAAU;IAvBpB,OAAO,CAAC,GAAG,CAAsD;IAGjE,OAAO,CAAC,qBAAqB,CAAO;IAGpC,OAAO,CAAC,mBAAmB,CAA0B;IAErD,OAAO,CAAC,MAAM,CAAiC;IAE/C,OAAO,CAAC,4BAA4B,CASlC;IAEF,YACU,aAAa,EAAE,yBAAyB,EACxC,UAAU,EAAE,UAAU,EAC9B,MAAM,EAAE,8BAA8B,EAKvC;IAEM,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,8BAA8B,CAAC,QAGrE;IAEM,KAAK,kBAMX;IAEM,IAAI,kBAMV;IAED,sGAAsG;IAC/F,uBAAuB,CAAC,KAAK,EAAE,8BAA8B,GAAG,IAAI,CAuB1E;IAED,OAAO,CAAC,+BAA+B;IA2BvC,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,gCAAgC;IAaxC,OAAO,CAAC,oBAAoB;CAS7B"}

package/dest/watchers/attestations_block_watcher.js

@@ -0,0 +1,142 @@
+import { SlotNumber } 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 { 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 checkpoints
+    maxInvalidCheckpoints;
+    // All invalid archive roots seen
+    invalidArchiveRoots;
+    config;
+    boundHandleInvalidCheckpoint;
+    constructor(l2BlockSource, epochCache, config){
+        super(), this.l2BlockSource = l2BlockSource, this.epochCache = epochCache, this.log = createLogger('attestations-block-watcher'), this.maxInvalidCheckpoints = 100, this.invalidArchiveRoots = new Set(), this.boundHandleInvalidCheckpoint = (event)=>{
+            try {
+                this.handleInvalidCheckpoint(event);
+            } catch (err) {
+                this.log.error('Error handling invalid checkpoint', 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.events.on(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, this.boundHandleInvalidCheckpoint);
+        return Promise.resolve();
+    }
+    stop() {
+        this.l2BlockSource.events.removeListener(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, this.boundHandleInvalidCheckpoint);
+        return Promise.resolve();
+    }
+    /** Event handler for invalid checkpoints as reported by the archiver. Public for testing purposes. */ handleInvalidCheckpoint(event) {
+        const { validationResult } = event;
+        const checkpoint = validationResult.checkpoint;
+        // Check if we already have processed this checkpoint, archiver may emit the same event multiple times
+        if (this.invalidArchiveRoots.has(checkpoint.archive.toString())) {
+            this.log.trace(`Already processed invalid checkpoint ${checkpoint.checkpointNumber}`);
+            return;
+        }
+        this.log.verbose(`Detected invalid checkpoint ${checkpoint.checkpointNumber}`, {
+            ...checkpoint,
+            reason: validationResult.valid === false ? validationResult.reason : 'unknown'
+        });
+        // Store the invalid checkpoint
+        this.addInvalidCheckpoint(event.validationResult.checkpoint);
+        // Slash the proposer of the invalid checkpoint
+        this.slashProposer(event.validationResult);
+        // Check if the parent of this checkpoint is invalid as well, if so, we will slash its attestors as well
+        this.slashAttestorsOnAncestorInvalid(event.validationResult);
+    }
+    slashAttestorsOnAncestorInvalid(validationResult) {
+        const checkpoint = validationResult.checkpoint;
+        const parentArchive = checkpoint.lastArchive.toString();
+        if (this.invalidArchiveRoots.has(parentArchive)) {
+            const attestors = validationResult.attestors;
+            this.log.info(`Want to slash attestors of checkpoint ${checkpoint.checkpointNumber} built on invalid checkpoint`, {
+                ...checkpoint,
+                ...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(SlotNumber(checkpoint.slotNumber))
+                })));
+        }
+    }
+    slashProposer(validationResult) {
+        const { reason, checkpoint } = validationResult;
+        const checkpointNumber = checkpoint.checkpointNumber;
+        const slot = checkpoint.slotNumber;
+        const epochCommitteeInfo = {
+            committee: validationResult.committee,
+            seed: validationResult.seed,
+            epoch: validationResult.epoch,
+            isEscapeHatchOpen: false
+        };
+        const proposer = this.epochCache.getProposerFromEpochCommittee(epochCommitteeInfo, slot);
+        if (!proposer) {
+            this.log.warn(`No proposer found for checkpoint ${checkpointNumber} at slot ${slot}`);
+            return;
+        }
+        const offense = this.getOffenseFromInvalidationReason(reason);
+        const amount = this.config.slashProposeInvalidAttestationsPenalty;
+        const args = {
+            validator: proposer,
+            amount,
+            offenseType: offense,
+            epochOrSlot: BigInt(slot)
+        };
+        this.log.info(`Want to slash proposer of checkpoint ${checkpointNumber} due to ${reason}`, {
+            ...checkpoint,
+            ...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;
+                }
+        }
+    }
+    addInvalidCheckpoint(checkpoint) {
+        this.invalidArchiveRoots.add(checkpoint.archive.toString());
+        // Prune old entries if we exceed the maximum
+        if (this.invalidArchiveRoots.size > this.maxInvalidCheckpoints) {
+            const oldestKey = this.invalidArchiveRoots.keys().next().value;
+            this.invalidArchiveRoots.delete(oldestKey);
+        }
+    }
+}

package/dest/watchers/epoch_prune_watcher.d.ts

@@ -0,0 +1,38 @@
+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

@@ -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,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"}