@aztec/slasher 0.0.1-commit.001888fc

package/dest/factory/create_implementation.js

@@ -0,0 +1,77 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+import { EmpireSlasherClient } from '../empire_slasher_client.js';
+import { NullSlasherClient } from '../null_slasher_client.js';
+import { SlasherOffensesStore } from '../stores/offenses_store.js';
+import { SlasherPayloadsStore } from '../stores/payloads_store.js';
+import { TallySlasherClient } from '../tally_slasher_client.js';
+import { getTallySlasherSettings } from './get_settings.js';
+/** Creates a slasher client implementation (either tally or empire) based on the slasher proposer type in the rollup */ export async function createSlasherImplementation(config, rollup, l1Client, slashFactoryAddress, watchers, epochCache, dateProvider, kvStore, rollupRegisteredAtL2Slot, logger = createLogger('slasher')) {
+    const proposer = await rollup.getSlashingProposer();
+    if (!proposer) {
+        return new NullSlasherClient(config);
+    } else if (proposer.type === 'tally') {
+        return createTallySlasher(config, rollup, proposer, watchers, dateProvider, epochCache, kvStore, rollupRegisteredAtL2Slot, logger);
+    } else {
+        if (!slashFactoryAddress || slashFactoryAddress.equals(EthAddress.ZERO)) {
+            throw new Error('Cannot initialize an empire-based SlasherClient without a SlashFactory address');
+        }
+        const slashFactory = new SlashFactoryContract(l1Client, slashFactoryAddress.toString());
+        return createEmpireSlasher(config, rollup, proposer, slashFactory, watchers, dateProvider, kvStore, rollupRegisteredAtL2Slot, logger);
+    }
+}
+async function createEmpireSlasher(config, rollup, slashingProposer, slashFactoryContract, watchers, dateProvider, kvStore, rollupRegisteredAtL2Slot, logger = createLogger('slasher')) {
+    if (slashingProposer.type !== 'empire') {
+        throw new Error('Slashing proposer contract is not of type Empire');
+    }
+    const [slashingExecutionDelayInRounds, slashingPayloadLifetimeInRounds, slashingRoundSize, slashingQuorumSize, epochDuration, proofSubmissionEpochs, l1GenesisTime, slotDuration, l1StartBlock, slasher] = await Promise.all([
+        slashingProposer.getExecutionDelayInRounds(),
+        slashingProposer.getLifetimeInRounds(),
+        slashingProposer.getRoundSize(),
+        slashingProposer.getQuorumSize(),
+        rollup.getEpochDuration(),
+        rollup.getProofSubmissionEpochs(),
+        rollup.getL1GenesisTime(),
+        rollup.getSlotDuration(),
+        rollup.getL1StartBlock(),
+        rollup.getSlasherContract()
+    ]);
+    const settings = {
+        slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
+        slashingPayloadLifetimeInRounds: Number(slashingPayloadLifetimeInRounds),
+        slashingRoundSize: Number(slashingRoundSize),
+        slashingQuorumSize: Number(slashingQuorumSize),
+        epochDuration: Number(epochDuration),
+        proofSubmissionEpochs: Number(proofSubmissionEpochs),
+        l1GenesisTime: l1GenesisTime,
+        slotDuration: Number(slotDuration),
+        l1StartBlock,
+        ethereumSlotDuration: config.ethereumSlotDuration,
+        slashingAmounts: undefined,
+        rollupRegisteredAtL2Slot
+    };
+    const payloadsStore = new SlasherPayloadsStore(kvStore, {
+        slashingPayloadLifetimeInRounds: settings.slashingPayloadLifetimeInRounds
+    });
+    const offensesStore = new SlasherOffensesStore(kvStore, {
+        ...settings,
+        slashOffenseExpirationRounds: config.slashOffenseExpirationRounds
+    });
+    return new EmpireSlasherClient(config, settings, slashFactoryContract, slashingProposer, slasher, rollup, watchers, dateProvider, offensesStore, payloadsStore, logger);
+}
+async function createTallySlasher(config, rollup, slashingProposer, watchers, dateProvider, epochCache, kvStore, rollupRegisteredAtL2Slot, logger = createLogger('slasher')) {
+    if (slashingProposer.type !== 'tally') {
+        throw new Error('Slashing proposer contract is not of type tally');
+    }
+    const settings = {
+        ...await getTallySlasherSettings(rollup, slashingProposer),
+        rollupRegisteredAtL2Slot
+    };
+    const slasher = await rollup.getSlasherContract();
+    const offensesStore = new SlasherOffensesStore(kvStore, {
+        ...settings,
+        slashOffenseExpirationRounds: config.slashOffenseExpirationRounds
+    });
+    return new TallySlasherClient(config, settings, slashingProposer, slasher, rollup, watchers, epochCache, dateProvider, offensesStore, logger);
+}

package/dest/factory/get_settings.d.ts

@@ -0,0 +1,4 @@
+import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import type { TallySlasherSettings } from '../tally_slasher_client.js';
+export declare function getTallySlasherSettings(rollup: RollupContract, slashingProposer?: TallySlashingProposerContract): Promise<Omit<TallySlasherSettings, 'rollupRegisteredAtL2Slot'>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3NldHRpbmdzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmFjdG9yeS9nZXRfc2V0dGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFL0YsT0FBTyxLQUFLLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUV2RSx3QkFBc0IsdUJBQXVCLENBQzNDLE1BQU0sRUFBRSxjQUFjLEVBQ3RCLGdCQUFnQixDQUFDLEVBQUUsNkJBQTZCLEdBQy9DLE9BQU8sQ0FBQyxJQUFJLENBQUMsb0JBQW9CLEVBQUUsMEJBQTBCLENBQUMsQ0FBQyxDQWtEakUifQ==

package/dest/factory/get_settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_settings.d.ts","sourceRoot":"","sources":["../../src/factory/get_settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAE/F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,cAAc,EACtB,gBAAgB,CAAC,EAAE,6BAA6B,GAC/C,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,0BAA0B,CAAC,CAAC,CAkDjE"}

package/dest/factory/get_settings.js

@@ -0,0 +1,36 @@
+export async function getTallySlasherSettings(rollup, slashingProposer) {
+    if (!slashingProposer) {
+        const rollupSlashingProposer = await rollup.getSlashingProposer();
+        if (!rollupSlashingProposer || rollupSlashingProposer.type !== 'tally') {
+            throw new Error('Rollup slashing proposer is not of type tally');
+        }
+        slashingProposer = rollupSlashingProposer;
+    }
+    const [slashingExecutionDelayInRounds, slashingRoundSize, slashingRoundSizeInEpochs, slashingLifetimeInRounds, slashingOffsetInRounds, slashingAmounts, slashingQuorumSize, epochDuration, l1GenesisTime, slotDuration, targetCommitteeSize] = await Promise.all([
+        slashingProposer.getExecutionDelayInRounds(),
+        slashingProposer.getRoundSize(),
+        slashingProposer.getRoundSizeInEpochs(),
+        slashingProposer.getLifetimeInRounds(),
+        slashingProposer.getSlashOffsetInRounds(),
+        slashingProposer.getSlashingAmounts(),
+        slashingProposer.getQuorumSize(),
+        rollup.getEpochDuration(),
+        rollup.getL1GenesisTime(),
+        rollup.getSlotDuration(),
+        rollup.getTargetCommitteeSize()
+    ]);
+    const settings = {
+        slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
+        slashingRoundSize: Number(slashingRoundSize),
+        slashingRoundSizeInEpochs: Number(slashingRoundSizeInEpochs),
+        slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
+        slashingQuorumSize: Number(slashingQuorumSize),
+        epochDuration: Number(epochDuration),
+        l1GenesisTime: l1GenesisTime,
+        slotDuration: Number(slotDuration),
+        slashingOffsetInRounds: Number(slashingOffsetInRounds),
+        slashingAmounts,
+        targetCommitteeSize: Number(targetCommitteeSize)
+    };
+    return settings;
+}

package/dest/factory/index.d.ts

@@ -0,0 +1,3 @@
+export { createSlasherFacade as createSlasher } from './create_facade.js';
+export { getTallySlasherSettings } from './get_settings.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mYWN0b3J5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsSUFBSSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMxRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQyJ9

package/dest/factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC"}

package/dest/factory/index.js

@@ -0,0 +1,2 @@
+export { createSlasherFacade as createSlasher } from './create_facade.js';
+export { getTallySlasherSettings } from './get_settings.js';

package/dest/generated/slasher-defaults.d.ts

@@ -0,0 +1,21 @@
+/** Default slasher configuration values from network-defaults.yml */
+export declare const slasherDefaultEnv: {
+    readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
+    readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
+    readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
+    readonly SLASH_MAX_PAYLOAD_SIZE: 80;
+    readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
+    readonly SLASH_PRUNE_PENALTY: 10000000000000000000;
+    readonly SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000;
+    readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9;
+    readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1;
+    readonly SLASH_INACTIVITY_PENALTY: 10000000000000000000;
+    readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000;
+    readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000;
+    readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 0;
+    readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 0;
+    readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
+    readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
+    readonly SLASH_GRACE_PERIOD_L2_SLOTS: 0;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhc2hlci1kZWZhdWx0cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2dlbmVyYXRlZC9zbGFzaGVyLWRlZmF1bHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLHFFQUFxRTtBQUNyRSxlQUFPLE1BQU0saUJBQWlCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FrQnBCLENBQUMifQ==

package/dest/generated/slasher-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slasher-defaults.d.ts","sourceRoot":"","sources":["../../src/generated/slasher-defaults.ts"],"names":[],"mappings":"AAGA,qEAAqE;AACrE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;CAkBpB,CAAC"}

package/dest/generated/slasher-defaults.js

@@ -0,0 +1,21 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+/** Default slasher configuration values from network-defaults.yml */ export const slasherDefaultEnv = {
+    SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
+    SLASH_MAX_PENALTY_PERCENTAGE: 2,
+    SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+    SLASH_MAX_PAYLOAD_SIZE: 80,
+    SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+    SLASH_PRUNE_PENALTY: 10000000000000000000,
+    SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+    SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
+    SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
+    SLASH_INACTIVITY_PENALTY: 10000000000000000000,
+    SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+    SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
+    SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
+    SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
+    SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+    SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+    SLASH_GRACE_PERIOD_L2_SLOTS: 0
+};

package/dest/index.d.ts

@@ -0,0 +1,11 @@
+export * from './config.js';
+export * from './watchers/epoch_prune_watcher.js';
+export * from './watchers/attestations_block_watcher.js';
+export * from './empire_slasher_client.js';
+export * from './tally_slasher_client.js';
+export * from './slash_offenses_collector.js';
+export * from './slasher_client_interface.js';
+export * from './factory/index.js';
+export * from './watcher.js';
+export * from '@aztec/stdlib/slashing';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUMifQ==

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,mCAAmC,CAAC;AAClD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC"}

package/dest/index.js

@@ -0,0 +1,10 @@
+export * from './config.js';
+export * from './watchers/epoch_prune_watcher.js';
+export * from './watchers/attestations_block_watcher.js';
+export * from './empire_slasher_client.js';
+export * from './tally_slasher_client.js';
+export * from './slash_offenses_collector.js';
+export * from './slasher_client_interface.js';
+export * from './factory/index.js';
+export * from './watcher.js';
+export * from '@aztec/stdlib/slashing';

package/dest/null_slasher_client.d.ts

@@ -0,0 +1,17 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
+import type { SlasherConfig } from './config.js';
+import type { SlasherClientInterface } from './slasher_client_interface.js';
+export declare class NullSlasherClient implements SlasherClientInterface {
+    private config;
+    constructor(config: SlasherConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getSlashPayloads(): Promise<SlashPayloadRound[]>;
+    gatherOffensesForRound(_round?: bigint): Promise<Offense[]>;
+    getPendingOffenses(): Promise<Offense[]>;
+    updateConfig(config: Partial<SlasherConfig>): void;
+    getProposerActions(_slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
+    getConfig(): SlasherConfig;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbF9zbGFzaGVyX2NsaWVudC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL251bGxfc2xhc2hlcl9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFOUYsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ2pELE9BQU8sS0FBSyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFNUUscUJBQWEsaUJBQWtCLFlBQVcsc0JBQXNCO0lBQ2xELE9BQU8sQ0FBQyxNQUFNO0lBQTFCLFlBQW9CLE1BQU0sRUFBRSxhQUFhLEVBQUk7SUFFdEMsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFNUI7SUFFTSxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUUzQjtJQUVNLGdCQUFnQixJQUFJLE9BQU8sQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLENBRXREO0lBRU0sc0JBQXNCLENBQUMsTUFBTSxDQUFDLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUVqRTtJQUVNLGtCQUFrQixJQUFJLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUU5QztJQUVNLFlBQVksQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLGFBQWEsQ0FBQyxHQUFHLElBQUksQ0FFeEQ7SUFFTSxrQkFBa0IsQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRSxDQUFDLENBRWpGO0lBRU0sU0FBUyxJQUFJLGFBQWEsQ0FFaEM7Q0FDRiJ9

package/dest/null_slasher_client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null_slasher_client.d.ts","sourceRoot":"","sources":["../src/null_slasher_client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,qBAAa,iBAAkB,YAAW,sBAAsB;IAClD,OAAO,CAAC,MAAM;IAA1B,YAAoB,MAAM,EAAE,aAAa,EAAI;IAEtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAEM,gBAAgB,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAEtD;IAEM,sBAAsB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAEjE;IAEM,kBAAkB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAE9C;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAExD;IAEM,kBAAkB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAEjF;IAEM,SAAS,IAAI,aAAa,CAEhC;CACF"}

package/dest/null_slasher_client.js

@@ -0,0 +1,33 @@
+export class NullSlasherClient {
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    start() {
+        return Promise.resolve();
+    }
+    stop() {
+        return Promise.resolve();
+    }
+    getSlashPayloads() {
+        return Promise.resolve([]);
+    }
+    gatherOffensesForRound(_round) {
+        return Promise.resolve([]);
+    }
+    getPendingOffenses() {
+        return Promise.resolve([]);
+    }
+    updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+    getProposerActions(_slotNumber) {
+        return Promise.resolve([]);
+    }
+    getConfig() {
+        return this.config;
+    }
+}

package/dest/slash_offenses_collector.d.ts

@@ -0,0 +1,48 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { Prettify } from '@aztec/foundation/types';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import { type OffenseIdentifier } from '@aztec/stdlib/slashing';
+import type { SlasherOffensesStore } from './stores/offenses_store.js';
+import { type WantToSlashArgs, type Watcher } from './watcher.js';
+export type SlashOffensesCollectorConfig = Prettify<Pick<SlasherConfig, 'slashGracePeriodL2Slots'>>;
+export type SlashOffensesCollectorSettings = Prettify<Pick<L1RollupConstants, 'epochDuration'> & {
+    slashingAmounts: [bigint, bigint, bigint] | undefined;
+    /** L2 slot at which the rollup was registered as canonical in the Registry. Used to anchor the slash grace period. */
+    rollupRegisteredAtL2Slot: SlotNumber;
+}>;
+/**
+ * Collects and manages slashable offenses from watchers.
+ * This class handles the common logic for subscribing to slash watcher events,
+ * storing offenses, and retrieving pending offenses for slashing.
+ */
+export declare class SlashOffensesCollector {
+    private readonly config;
+    private readonly settings;
+    private readonly watchers;
+    private readonly offensesStore;
+    private readonly log;
+    private readonly unwatchCallbacks;
+    constructor(config: SlashOffensesCollectorConfig, settings: SlashOffensesCollectorSettings, watchers: Watcher[], offensesStore: SlasherOffensesStore, log?: import("@aztec/foundation/log").Logger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Called when a slash watcher emits WANT_TO_SLASH_EVENT.
+     * Stores pending offenses instead of creating payloads immediately.
+     * @param args - the arguments from the watcher, including the validators, amounts, and offenses
+     */
+    handleWantToSlash(args: WantToSlashArgs[]): Promise<void>;
+    /**
+     * Triggered on a time basis when we enter a new slashing round.
+     * Clears expired offenses from stores.
+     */
+    handleNewRound(round: bigint): Promise<void>;
+    /**
+     * Marks offenses as slashed (no longer pending)
+     * @param offenses - The offenses to mark as slashed
+     */
+    markAsSlashed(offenses: OffenseIdentifier[]): Promise<void>;
+    /** Returns whether to skip an offense if it happened during the grace period after the network upgrade */
+    private shouldSkipOffense;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhc2hfb2ZmZW5zZXNfY29sbGVjdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc2xhc2hfb2ZmZW5zZXNfY29sbGVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRWxFLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDckUsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDckUsT0FBTyxFQUFnQixLQUFLLGlCQUFpQixFQUFxQixNQUFNLHdCQUF3QixDQUFDO0FBRWpHLE9BQU8sS0FBSyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDdkUsT0FBTyxFQUF1QixLQUFLLGVBQWUsRUFBRSxLQUFLLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUV2RixNQUFNLE1BQU0sNEJBQTRCLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUseUJBQXlCLENBQUMsQ0FBQyxDQUFDO0FBQ3BHLE1BQU0sTUFBTSw4QkFBOEIsR0FBRyxRQUFRLENBQ25ELElBQUksQ0FBQyxpQkFBaUIsRUFBRSxlQUFlLENBQUMsR0FBRztJQUN6QyxlQUFlLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxHQUFHLFNBQVMsQ0FBQztJQUN0RCxzSEFBc0g7SUFDdEgsd0JBQXdCLEVBQUUsVUFBVSxDQUFDO0NBQ3RDLENBQ0YsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCxxQkFBYSxzQkFBc0I7SUFJL0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUTtJQUN6QixPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVE7SUFDekIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhO0lBQzlCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRztJQVB0QixPQUFPLENBQUMsUUFBUSxDQUFDLGdCQUFnQixDQUFzQjtJQUV2RCxZQUNtQixNQUFNLEVBQUUsNEJBQTRCLEVBQ3BDLFFBQVEsRUFBRSw4QkFBOEIsRUFDeEMsUUFBUSxFQUFFLE9BQU8sRUFBRSxFQUNuQixhQUFhLEVBQUUsb0JBQW9CLEVBQ25DLEdBQUcseUNBQTZDLEVBQy9EO0lBRUcsS0FBSyxrQkFhWDtJQUVNLElBQUksa0JBU1Y7SUFFRDs7OztPQUlHO0lBQ1UsaUJBQWlCLENBQUMsSUFBSSxFQUFFLGVBQWUsRUFBRSxpQkE2QnJEO0lBRUQ7OztPQUdHO0lBQ1UsY0FBYyxDQUFDLEtBQUssRUFBRSxNQUFNLGlCQUt4QztJQUVEOzs7T0FHRztJQUNJLGFBQWEsQ0FBQyxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsaUJBR2pEO0lBRUQsMEdBQTBHO0lBQzFHLE9BQU8sQ0FBQyxpQkFBaUI7Q0FJMUIifQ==

package/dest/slash_offenses_collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash_offenses_collector.d.ts","sourceRoot":"","sources":["../src/slash_offenses_collector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAgB,KAAK,iBAAiB,EAAqB,MAAM,wBAAwB,CAAC;AAEjG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAuB,KAAK,eAAe,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvF,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,yBAAyB,CAAC,CAAC,CAAC;AACpG,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CACnD,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAAG;IACzC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACtD,sHAAsH;IACtH,wBAAwB,EAAE,UAAU,CAAC;CACtC,CACF,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAsB;IAI/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAPtB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IAEvD,YACmB,MAAM,EAAE,4BAA4B,EACpC,QAAQ,EAAE,8BAA8B,EACxC,QAAQ,EAAE,OAAO,EAAE,EACnB,aAAa,EAAE,oBAAoB,EACnC,GAAG,yCAA6C,EAC/D;IAEG,KAAK,kBAaX;IAEM,IAAI,kBASV;IAED;;;;OAIG;IACU,iBAAiB,CAAC,IAAI,EAAE,eAAe,EAAE,iBA6BrD;IAED;;;OAGG;IACU,cAAc,CAAC,KAAK,EAAE,MAAM,iBAKxC;IAED;;;OAGG;IACI,aAAa,CAAC,QAAQ,EAAE,iBAAiB,EAAE,iBAGjD;IAED,0GAA0G;IAC1G,OAAO,CAAC,iBAAiB;CAI1B"}

package/dest/slash_offenses_collector.js

@@ -0,0 +1,94 @@
+import { createLogger } from '@aztec/foundation/log';
+import { getSlotForOffense } from '@aztec/stdlib/slashing';
+import { WANT_TO_SLASH_EVENT } from './watcher.js';
+/**
+ * Collects and manages slashable offenses from watchers.
+ * This class handles the common logic for subscribing to slash watcher events,
+ * storing offenses, and retrieving pending offenses for slashing.
+ */ export class SlashOffensesCollector {
+    config;
+    settings;
+    watchers;
+    offensesStore;
+    log;
+    unwatchCallbacks;
+    constructor(config, settings, watchers, offensesStore, log = createLogger('slasher:offenses-collector')){
+        this.config = config;
+        this.settings = settings;
+        this.watchers = watchers;
+        this.offensesStore = offensesStore;
+        this.log = log;
+        this.unwatchCallbacks = [];
+    }
+    start() {
+        this.log.debug('Starting SlashOffensesCollector...');
+        // Subscribe to watchers WANT_TO_SLASH_EVENT
+        for (const watcher of this.watchers){
+            const wantToSlashCallback = (args)=>void this.handleWantToSlash(args).catch((err)=>this.log.error('Error handling wantToSlash', err));
+            watcher.on(WANT_TO_SLASH_EVENT, wantToSlashCallback);
+            this.unwatchCallbacks.push(()=>watcher.removeListener(WANT_TO_SLASH_EVENT, wantToSlashCallback));
+        }
+        this.log.info('Started SlashOffensesCollector');
+        return Promise.resolve();
+    }
+    stop() {
+        this.log.debug('Stopping SlashOffensesCollector...');
+        for (const unwatchCallback of this.unwatchCallbacks){
+            unwatchCallback();
+        }
+        this.log.info('SlashOffensesCollector stopped');
+        return Promise.resolve();
+    }
+    /**
+   * Called when a slash watcher emits WANT_TO_SLASH_EVENT.
+   * Stores pending offenses instead of creating payloads immediately.
+   * @param args - the arguments from the watcher, including the validators, amounts, and offenses
+   */ async handleWantToSlash(args) {
+        for (const arg of args){
+            const pendingOffense = {
+                validator: arg.validator,
+                amount: arg.amount,
+                offenseType: arg.offenseType,
+                epochOrSlot: arg.epochOrSlot
+            };
+            if (this.shouldSkipOffense(pendingOffense)) {
+                this.log.verbose('Skipping offense during grace period', pendingOffense);
+                continue;
+            }
+            if (await this.offensesStore.hasOffense(pendingOffense)) {
+                this.log.debug('Skipping repeated offense', pendingOffense);
+                continue;
+            }
+            if (this.settings.slashingAmounts) {
+                const minSlash = this.settings.slashingAmounts[0];
+                if (arg.amount < minSlash) {
+                    this.log.warn(`Offense amount ${arg.amount} is below minimum slashing amount ${minSlash}`);
+                }
+            }
+            this.log.info(`Adding pending offense for validator ${arg.validator}`, pendingOffense);
+            await this.offensesStore.addPendingOffense(pendingOffense);
+        }
+    }
+    /**
+   * Triggered on a time basis when we enter a new slashing round.
+   * Clears expired offenses from stores.
+   */ async handleNewRound(round) {
+        const cleared = await this.offensesStore.clearExpiredOffenses(round);
+        if (cleared && cleared > 0) {
+            this.log.debug(`Cleared ${cleared} expired offenses for round ${round}`);
+        }
+    }
+    /**
+   * Marks offenses as slashed (no longer pending)
+   * @param offenses - The offenses to mark as slashed
+   */ markAsSlashed(offenses) {
+        this.log.verbose(`Marking offenses as slashed`, {
+            offenses
+        });
+        return this.offensesStore.markAsSlashed(offenses);
+    }
+    /** Returns whether to skip an offense if it happened during the grace period after the network upgrade */ shouldSkipOffense(offense) {
+        const offenseSlot = getSlotForOffense(offense, this.settings);
+        return offenseSlot < this.settings.rollupRegisteredAtL2Slot + this.config.slashGracePeriodL2Slots;
+    }
+}

package/dest/slash_round_monitor.d.ts

@@ -0,0 +1,30 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { Prettify } from '@aztec/foundation/types';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+export type SlashRoundMonitorSettings = Prettify<Pick<L1RollupConstants, 'epochDuration' | 'l1GenesisTime' | 'slotDuration'> & {
+    slashingRoundSize: number;
+}>;
+export declare class SlashRoundMonitor {
+    private settings;
+    private dateProvider;
+    private log;
+    private currentRound;
+    private intervalId;
+    private handler;
+    constructor(settings: SlashRoundMonitorSettings, dateProvider: DateProvider, log?: import("@aztec/foundation/log").Logger);
+    start(): void;
+    stop(): void;
+    listenToNewRound(handler: (round: bigint) => Promise<void>): () => void;
+    /** Returns the slashing round number and the voting slot within the round based on the L2 chain slot */
+    getRoundForSlot(slotNumber: SlotNumber): {
+        round: bigint;
+        votingSlot: SlotNumber;
+    };
+    /** Returns the current slashing round and voting slot within the round */
+    getCurrentRound(): {
+        round: bigint;
+        votingSlot: SlotNumber;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhc2hfcm91bmRfbW9uaXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3NsYXNoX3JvdW5kX21vbml0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTdELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUFzQixNQUFNLDZCQUE2QixDQUFDO0FBR3pGLE1BQU0sTUFBTSx5QkFBeUIsR0FBRyxRQUFRLENBQzlDLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxlQUFlLEdBQUcsZUFBZSxHQUFHLGNBQWMsQ0FBQyxHQUFHO0lBQUUsaUJBQWlCLEVBQUUsTUFBTSxDQUFBO0NBQUUsQ0FDNUcsQ0FBQztBQUVGLHFCQUFhLGlCQUFpQjtJQU0xQixPQUFPLENBQUMsUUFBUTtJQUNoQixPQUFPLENBQUMsWUFBWTtJQUNwQixPQUFPLENBQUMsR0FBRztJQVBiLE9BQU8sQ0FBQyxZQUFZLENBQWM7SUFDbEMsT0FBTyxDQUFDLFVBQVUsQ0FBeUM7SUFDM0QsT0FBTyxDQUFDLE9BQU8sQ0FBNkQ7SUFFNUUsWUFDVSxRQUFRLEVBQUUseUJBQXlCLEVBQ25DLFlBQVksRUFBRSxZQUFZLEVBQzFCLEdBQUcseUNBQXdDLEVBQ2pEO0lBRUcsS0FBSyxTQVlYO0lBRU0sSUFBSSxTQUtWO0lBRU0sZ0JBQWdCLENBQUMsT0FBTyxFQUFFLENBQUMsS0FBSyxFQUFFLE1BQU0sS0FBSyxPQUFPLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxJQUFJLENBSzdFO0lBRUQsd0dBQXdHO0lBQ2pHLGVBQWUsQ0FBQyxVQUFVLEVBQUUsVUFBVSxHQUFHO1FBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQztRQUFDLFVBQVUsRUFBRSxVQUFVLENBQUE7S0FBRSxDQUV4RjtJQUVELDBFQUEwRTtJQUNuRSxlQUFlLElBQUk7UUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDO1FBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQTtLQUFFLENBSWxFO0NBQ0YifQ==

package/dest/slash_round_monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash_round_monitor.d.ts","sourceRoot":"","sources":["../src/slash_round_monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,KAAK,iBAAiB,EAAsB,MAAM,6BAA6B,CAAC;AAGzF,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAC9C,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,eAAe,GAAG,cAAc,CAAC,GAAG;IAAE,iBAAiB,EAAE,MAAM,CAAA;CAAE,CAC5G,CAAC;AAEF,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,GAAG;IAPb,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,UAAU,CAAyC;IAC3D,OAAO,CAAC,OAAO,CAA6D;IAE5E,YACU,QAAQ,EAAE,yBAAyB,EACnC,YAAY,EAAE,YAAY,EAC1B,GAAG,yCAAwC,EACjD;IAEG,KAAK,SAYX;IAEM,IAAI,SAKV;IAEM,gBAAgB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAK7E;IAED,wGAAwG;IACjG,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,UAAU,CAAA;KAAE,CAExF;IAED,0EAA0E;IACnE,eAAe,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,UAAU,CAAA;KAAE,CAIlE;CACF"}

package/dest/slash_round_monitor.js

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

package/dest/slasher_client_facade.d.ts

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

package/dest/slasher_client_facade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slasher_client_facade.d.ts","sourceRoot":"","sources":["../src/slasher_client_facade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAG9F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,mBAAoB,YAAW,sBAAsB;IAK9D,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,wBAAwB;IAChC,OAAO,CAAC,MAAM;IAbhB,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,OAAO,CAA2B;IAE1C,YACU,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG;QAAE,oBAAoB,EAAE,MAAM,CAAA;KAAE,EAC1E,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,UAAU,EACpB,mBAAmB,EAAE,UAAU,GAAG,SAAS,EAC3C,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,gBAAgB,EACzB,wBAAwB,EAAE,UAAU,EACpC,MAAM,yCAA0B,EACtC;IAES,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CASlC;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAIjC;IAEM,SAAS,IAAI,aAAa,CAEhC;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAIxD;IAEM,gBAAgB,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAEtD;IAEM,sBAAsB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAEhE;IAEM,kBAAkB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAE9C;IAEM,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAEhF;IAED,OAAO,CAAC,mBAAmB;YAeb,mBAAmB;CAMlC"}