@aztec/slasher 0.0.1-commit.21caa21

package/dest/slasher_client_interface.js

@@ -0,0 +1,4 @@
+/**
+ * Common interface for slasher clients used by the Aztec node.
+ * Both Empire and Consensus slasher clients implement this interface.
+ */ export { };

package/dest/stores/offenses_store.d.ts

@@ -0,0 +1,37 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { type Offense, type OffenseIdentifier } from '@aztec/stdlib/slashing';
+export declare const SCHEMA_VERSION = 1;
+export declare class SlasherOffensesStore {
+    private kvStore;
+    private settings;
+    /** Map from offense key to offense data */
+    private offenses;
+    /** Map from offense key to whether the offense has been executed (only used for empire based slashing) */
+    private offensesSlashed;
+    /** Multimap from round to offense keys (only used for consensus based slashing) */
+    private roundsOffenses;
+    private log;
+    constructor(kvStore: AztecAsyncKVStore, settings: {
+        slashingRoundSize: number;
+        epochDuration: number;
+        slashOffenseExpirationRounds?: number;
+    });
+    /** Returns all offenses not marked as slashed */
+    getPendingOffenses(): Promise<Offense[]>;
+    /** Returns all offenses tracked for the given round */
+    getOffensesForRound(round: bigint): Promise<Offense[]>;
+    /** Returns whether an offense is pending (ie not marked as slashed) */
+    hasPendingOffense(offense: OffenseIdentifier): Promise<boolean>;
+    /** Returns whether we have seen this offense */
+    hasOffense(offense: OffenseIdentifier): Promise<boolean>;
+    /** Adds a new offense (defaults to pending, but will be slashed if markAsSlashed had been called for it) */
+    addPendingOffense(offense: Offense): Promise<void>;
+    /** Marks the given offenses as slashed (regardless of whether they are known or not)  */
+    markAsSlashed(offenses: OffenseIdentifier[]): Promise<void>;
+    /** Prunes all offenses expired from the store */
+    clearExpiredOffenses(currentRound: bigint): Promise<number>;
+    /** Generate a unique key for an offense */
+    private getOffenseKey;
+    private getRoundKey;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2ZmZW5zZXNfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdG9yZXMvb2ZmZW5zZXNfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQW9ELE1BQU0saUJBQWlCLENBQUM7QUFDM0csT0FBTyxFQUNMLEtBQUssT0FBTyxFQUNaLEtBQUssaUJBQWlCLEVBSXZCLE1BQU0sd0JBQXdCLENBQUM7QUFFaEMsZUFBTyxNQUFNLGNBQWMsSUFBSSxDQUFDO0FBRWhDLHFCQUFhLG9CQUFvQjtJQWE3QixPQUFPLENBQUMsT0FBTztJQUNmLE9BQU8sQ0FBQyxRQUFRO0lBYmxCLDJDQUEyQztJQUMzQyxPQUFPLENBQUMsUUFBUSxDQUFnQztJQUVoRCwwR0FBMEc7SUFDMUcsT0FBTyxDQUFDLGVBQWUsQ0FBd0I7SUFFL0MsbUZBQW1GO0lBQ25GLE9BQU8sQ0FBQyxjQUFjLENBQXFDO0lBRTNELE9BQU8sQ0FBQyxHQUFHLENBQTBDO0lBRXJELFlBQ1UsT0FBTyxFQUFFLGlCQUFpQixFQUMxQixRQUFRLEVBQUU7UUFDaEIsaUJBQWlCLEVBQUUsTUFBTSxDQUFDO1FBQzFCLGFBQWEsRUFBRSxNQUFNLENBQUM7UUFDdEIsNEJBQTRCLENBQUMsRUFBRSxNQUFNLENBQUM7S0FDdkMsRUFLRjtJQUVELGlEQUFpRDtJQUNwQyxrQkFBa0IsSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FVcEQ7SUFFRCx1REFBdUQ7SUFDMUMsbUJBQW1CLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FVbEU7SUFFRCx1RUFBdUU7SUFDMUQsaUJBQWlCLENBQUMsT0FBTyxFQUFFLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FHM0U7SUFFRCxnREFBZ0Q7SUFDbkMsVUFBVSxDQUFDLE9BQU8sRUFBRSxpQkFBaUIsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBR3BFO0lBRUQsNEdBQTRHO0lBQy9GLGlCQUFpQixDQUFDLE9BQU8sRUFBRSxPQUFPLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQU05RDtJQUVELHlGQUF5RjtJQUM1RSxhQUFhLENBQUMsUUFBUSxFQUFFLGlCQUFpQixFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQU92RTtJQUVELGlEQUFpRDtJQUNwQyxvQkFBb0IsQ0FBQyxZQUFZLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0F1Q3ZFO0lBRUQsMkNBQTJDO0lBQzNDLE9BQU8sQ0FBQyxhQUFhO0lBSXJCLE9BQU8sQ0FBQyxXQUFXO0NBR3BCIn0=

package/dest/stores/offenses_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offenses_store.d.ts","sourceRoot":"","sources":["../../src/stores/offenses_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAoD,MAAM,iBAAiB,CAAC;AAC3G,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,iBAAiB,EAIvB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,qBAAa,oBAAoB;IAa7B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IAblB,2CAA2C;IAC3C,OAAO,CAAC,QAAQ,CAAgC;IAEhD,0GAA0G;IAC1G,OAAO,CAAC,eAAe,CAAwB;IAE/C,mFAAmF;IACnF,OAAO,CAAC,cAAc,CAAqC;IAE3D,OAAO,CAAC,GAAG,CAA0C;IAErD,YACU,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE;QAChB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,aAAa,EAAE,MAAM,CAAC;QACtB,4BAA4B,CAAC,EAAE,MAAM,CAAC;KACvC,EAKF;IAED,iDAAiD;IACpC,kBAAkB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAUpD;IAED,uDAAuD;IAC1C,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAUlE;IAED,uEAAuE;IAC1D,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAG3E;IAED,gDAAgD;IACnC,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAGpE;IAED,4GAA4G;IAC/F,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAM9D;IAED,yFAAyF;IAC5E,aAAa,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAOvE;IAED,iDAAiD;IACpC,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAuCvE;IAED,2CAA2C;IAC3C,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,WAAW;CAGpB"}

package/dest/stores/offenses_store.js

@@ -0,0 +1,105 @@
+import { createLogger } from '@aztec/aztec.js/log';
+import { deserializeOffense, getRoundForOffense, serializeOffense } from '@aztec/stdlib/slashing';
+export const SCHEMA_VERSION = 1;
+export class SlasherOffensesStore {
+    kvStore;
+    settings;
+    /** Map from offense key to offense data */ offenses;
+    /** Map from offense key to whether the offense has been executed (only used for empire based slashing) */ offensesSlashed;
+    /** Multimap from round to offense keys (only used for consensus based slashing) */ roundsOffenses;
+    log;
+    constructor(kvStore, settings){
+        this.kvStore = kvStore;
+        this.settings = settings;
+        this.log = createLogger('slasher:store:offenses');
+        this.offenses = kvStore.openMap('offenses');
+        this.roundsOffenses = kvStore.openMultiMap('rounds-offenses');
+        this.offensesSlashed = kvStore.openSet('offenses-slashed');
+    }
+    /** Returns all offenses not marked as slashed */ async getPendingOffenses() {
+        const offenses = [];
+        for await (const [key, buffer] of this.offenses.entriesAsync()){
+            if (await this.offensesSlashed.hasAsync(key)) {
+                continue; // Skip executed offenses
+            }
+            const offense = deserializeOffense(buffer);
+            offenses.push(offense);
+        }
+        return offenses;
+    }
+    /** Returns all offenses tracked for the given round */ async getOffensesForRound(round) {
+        const offenses = [];
+        for await (const key of this.roundsOffenses.getValuesAsync(this.getRoundKey(round))){
+            const buffer = await this.offenses.getAsync(key);
+            if (buffer) {
+                const offense = deserializeOffense(buffer);
+                offenses.push(offense);
+            }
+        }
+        return offenses;
+    }
+    /** Returns whether an offense is pending (ie not marked as slashed) */ async hasPendingOffense(offense) {
+        const key = this.getOffenseKey(offense);
+        return await this.offenses.getAsync(key) !== undefined && !await this.offensesSlashed.hasAsync(key);
+    }
+    /** Returns whether we have seen this offense */ async hasOffense(offense) {
+        const key = this.getOffenseKey(offense);
+        return await this.offenses.getAsync(key) !== undefined;
+    }
+    /** Adds a new offense (defaults to pending, but will be slashed if markAsSlashed had been called for it) */ async addPendingOffense(offense) {
+        const key = this.getOffenseKey(offense);
+        await this.offenses.set(key, serializeOffense(offense));
+        const round = getRoundForOffense(offense, this.settings);
+        await this.roundsOffenses.set(this.getRoundKey(round), key);
+        this.log.trace(`Adding pending offense ${key} for round ${round}`);
+    }
+    /** Marks the given offenses as slashed (regardless of whether they are known or not)  */ async markAsSlashed(offenses) {
+        await this.kvStore.transactionAsync(async ()=>{
+            for (const offense of offenses){
+                const key = this.getOffenseKey(offense);
+                await this.offensesSlashed.add(key);
+            }
+        });
+    }
+    /** Prunes all offenses expired from the store */ async clearExpiredOffenses(currentRound) {
+        const expirationRounds = this.settings.slashOffenseExpirationRounds ?? 0;
+        if (expirationRounds <= 0) {
+            return 0; // No expiration configured
+        }
+        const expiredBefore = currentRound - BigInt(expirationRounds);
+        if (expiredBefore < 0) {
+            return 0; // Not enough rounds have passed to expire anything
+        }
+        // Collect expired offenses and rounds
+        const expiredRoundKeys = new Set();
+        const expiredOffenseKeys = new Set();
+        for await (const [roundKey, offenseKey] of this.roundsOffenses.entriesAsync({
+            end: this.getRoundKey(expiredBefore)
+        })){
+            expiredOffenseKeys.add(offenseKey);
+            expiredRoundKeys.add(roundKey);
+        }
+        if (expiredOffenseKeys.size === 0 && expiredRoundKeys.size === 0) {
+            return 0; // Nothing to clean up
+        }
+        // Remove expired stuff in a transaction
+        await this.kvStore.transactionAsync(async ()=>{
+            for (const key of expiredOffenseKeys){
+                this.log.trace(`Deleting offense ${key}`);
+                await this.offenses.delete(key);
+                await this.offensesSlashed.delete(key);
+            }
+            for (const roundKey of expiredRoundKeys){
+                this.log.trace(`Deleting round info for ${roundKey}`);
+                await this.roundsOffenses.delete(roundKey);
+            }
+        });
+        return expiredOffenseKeys.size;
+    }
+    /** Generate a unique key for an offense */ getOffenseKey(offense) {
+        return `${offense.validator.toString()}:${offense.offenseType}:${offense.epochOrSlot}`;
+    }
+    getRoundKey(round) {
+        return round.toString().padStart(16, '0');
+    }
+}

package/dest/stores/payloads_store.d.ts

@@ -0,0 +1,29 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { type SlashPayload, type SlashPayloadRound } from '@aztec/stdlib/slashing';
+export declare class SlasherPayloadsStore {
+    private kvStore;
+    private settings?;
+    /** Map from payload address to payload data */
+    private payloads;
+    /** Map from `round:payload` to votes */
+    private roundPayloadVotes;
+    constructor(kvStore: AztecAsyncKVStore, settings?: {
+        slashingPayloadLifetimeInRounds?: number | undefined;
+    } | undefined);
+    getPayloadsForRound(round: bigint): Promise<SlashPayloadRound[]>;
+    getPayloadAtRound(payloadAddress: EthAddress, round: bigint): Promise<SlashPayloadRound | undefined>;
+    private getVotesForRound;
+    private getRoundKey;
+    private getPayloadVotesKey;
+    private getPayloadVotesKeyRangeForRound;
+    /**
+     * Purge vote payload data for expired rounds. Does not delete actual payload data.
+     */
+    clearExpiredPayloads(currentRound: bigint): Promise<void>;
+    incrementPayloadVotes(payloadAddress: EthAddress, round: bigint): Promise<bigint>;
+    addPayload(payload: SlashPayloadRound): Promise<void>;
+    getPayload(payloadAddress: EthAddress | string): Promise<SlashPayload | undefined>;
+    hasPayload(payload: EthAddress): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bG9hZHNfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdG9yZXMvcGF5bG9hZHNfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sRUFDTCxLQUFLLFlBQVksRUFDakIsS0FBSyxpQkFBaUIsRUFHdkIsTUFBTSx3QkFBd0IsQ0FBQztBQUVoQyxxQkFBYSxvQkFBb0I7SUFRN0IsT0FBTyxDQUFDLE9BQU87SUFDZixPQUFPLENBQUMsUUFBUSxDQUFDO0lBUm5CLCtDQUErQztJQUMvQyxPQUFPLENBQUMsUUFBUSxDQUFnQztJQUVoRCx3Q0FBd0M7SUFDeEMsT0FBTyxDQUFDLGlCQUFpQixDQUFnQztJQUV6RCxZQUNVLE9BQU8sRUFBRSxpQkFBaUIsRUFDMUIsUUFBUSxDQUFDOztpQkFFaEIsRUFJRjtJQUVZLG1CQUFtQixDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLGlCQUFpQixFQUFFLENBQUMsQ0FVNUU7SUFFWSxpQkFBaUIsQ0FBQyxjQUFjLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLGlCQUFpQixHQUFHLFNBQVMsQ0FBQyxDQVdoSDtZQUVhLGdCQUFnQjtJQVk5QixPQUFPLENBQUMsV0FBVztJQUluQixPQUFPLENBQUMsa0JBQWtCO0lBSTFCLE9BQU8sQ0FBQywrQkFBK0I7SUFNdkM7O09BRUc7SUFDVSxvQkFBb0IsQ0FBQyxZQUFZLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FvQ3JFO0lBRVkscUJBQXFCLENBQUMsY0FBYyxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FNN0Y7SUFFWSxVQUFVLENBQUMsT0FBTyxFQUFFLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FPakU7SUFFWSxVQUFVLENBQUMsY0FBYyxFQUFFLFVBQVUsR0FBRyxNQUFNLEdBQUcsT0FBTyxDQUFDLFlBQVksR0FBRyxTQUFTLENBQUMsQ0FJOUY7SUFFWSxVQUFVLENBQUMsT0FBTyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBRzdEO0NBQ0YifQ==

package/dest/stores/payloads_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payloads_store.d.ts","sourceRoot":"","sources":["../../src/stores/payloads_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EAGvB,MAAM,wBAAwB,CAAC;AAEhC,qBAAa,oBAAoB;IAQ7B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ,CAAC;IARnB,+CAA+C;IAC/C,OAAO,CAAC,QAAQ,CAAgC;IAEhD,wCAAwC;IACxC,OAAO,CAAC,iBAAiB,CAAgC;IAEzD,YACU,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,CAAC;;iBAEhB,EAIF;IAEY,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAU5E;IAEY,iBAAiB,CAAC,cAAc,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAWhH;YAEa,gBAAgB;IAY9B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,+BAA+B;IAMvC;;OAEG;IACU,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCrE;IAEY,qBAAqB,CAAC,cAAc,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAM7F;IAEY,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjE;IAEY,UAAU,CAAC,cAAc,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAI9F;IAEY,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAG7D;CACF"}

package/dest/stores/payloads_store.js

@@ -0,0 +1,125 @@
+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);
+        const currentVotes = await this.roundPayloadVotes.getAsync(key) || 0n;
+        const 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/stores/schema_version.d.ts

@@ -0,0 +1,2 @@
+export declare const SCHEMA_VERSION = 1;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hX3ZlcnNpb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdG9yZXMvc2NoZW1hX3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBTyxNQUFNLGNBQWMsSUFBSSxDQUFDIn0=

package/dest/stores/schema_version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_version.d.ts","sourceRoot":"","sources":["../../src/stores/schema_version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,IAAI,CAAC"}

package/dest/stores/schema_version.js

@@ -0,0 +1 @@
+export const SCHEMA_VERSION = 1;

package/dest/tally_slasher_client.d.ts

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

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