@aztec/slasher 0.0.1-commit.fce3e4f → 0.0.1-commit.ff7989d6c

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

@@ -1 +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,EAGL,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAC;AAK7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAA6C,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7G,QAAA,MAAM,kCAAkC,8FAG9B,CAAC;AAEX,KAAK,8BAA8B,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,kCAAkC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;;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,gBAAgB,CAAO;IAG/B,OAAO,CAAC,mBAAmB,CAA0B;IAErD,OAAO,CAAC,MAAM,CAAiC;IAE/C,OAAO,CAAC,uBAAuB,CAS7B;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,kBAGX;IAEM,IAAI,kBAMV;IAED,OAAO,CAAC,kBAAkB;IAyB1B,OAAO,CAAC,+BAA+B;IAwBvC,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,gCAAgC;IAaxC,OAAO,CAAC,eAAe;CASxB"}
+{"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

@@ -18,18 +18,18 @@ const AttestationsBlockWatcherConfigKeys = [
     l2BlockSource;
     epochCache;
     log;
-    // Only keep track of the last N invalid blocks
-    maxInvalidBlocks;
+    // Only keep track of the last N invalid checkpoints
+    maxInvalidCheckpoints;
     // All invalid archive roots seen
     invalidArchiveRoots;
     config;
-    boundHandleInvalidBlock;
+    boundHandleInvalidCheckpoint;
     constructor(l2BlockSource, epochCache, config){
-        super(), this.l2BlockSource = l2BlockSource, this.epochCache = epochCache, this.log = createLogger('attestations-block-watcher'), this.maxInvalidBlocks = 100, this.invalidArchiveRoots = new Set(), this.boundHandleInvalidBlock = (event)=>{
+        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.handleInvalidBlock(event);
+                this.handleInvalidCheckpoint(event);
             } catch (err) {
-                this.log.error('Error handling invalid block', err, {
+                this.log.error('Error handling invalid checkpoint', err, {
                     ...event.validationResult,
                     reason: event.validationResult.reason
                 });
@@ -43,39 +43,39 @@ const AttestationsBlockWatcherConfigKeys = [
         this.log.verbose('AttestationsBlockWatcher config updated', this.config);
     }
     start() {
-        this.l2BlockSource.on(L2BlockSourceEvents.InvalidAttestationsBlockDetected, this.boundHandleInvalidBlock);
+        this.l2BlockSource.events.on(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, this.boundHandleInvalidCheckpoint);
         return Promise.resolve();
     }
     stop() {
-        this.l2BlockSource.removeListener(L2BlockSourceEvents.InvalidAttestationsBlockDetected, this.boundHandleInvalidBlock);
+        this.l2BlockSource.events.removeListener(L2BlockSourceEvents.InvalidAttestationsCheckpointDetected, this.boundHandleInvalidCheckpoint);
         return Promise.resolve();
     }
-    handleInvalidBlock(event) {
+    /** Event handler for invalid checkpoints as reported by the archiver. Public for testing purposes. */ handleInvalidCheckpoint(event) {
         const { validationResult } = event;
-        const block = validationResult.block;
-        // Check if we already have processed this block, archiver may emit the same event multiple times
-        if (this.invalidArchiveRoots.has(block.archive.toString())) {
-            this.log.trace(`Already processed invalid block ${block.blockNumber}`);
+        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 block ${block.blockNumber}`, {
-            ...block,
+        this.log.verbose(`Detected invalid checkpoint ${checkpoint.checkpointNumber}`, {
+            ...checkpoint,
             reason: validationResult.valid === false ? validationResult.reason : 'unknown'
         });
-        // Store the invalid block
-        this.addInvalidBlock(event.validationResult.block);
-        // Slash the proposer of the invalid block
+        // 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 block is invalid as well, if so, we will slash its attestors as well
+        // 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 block = validationResult.block;
-        const parentArchive = block.lastArchive.toString();
+        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 block ${block.blockNumber} built on invalid block`, {
-                ...block,
+            this.log.info(`Want to slash attestors of checkpoint ${checkpoint.checkpointNumber} built on invalid checkpoint`, {
+                ...checkpoint,
                 ...attestors,
                 parentArchive
             });
@@ -83,17 +83,23 @@ const AttestationsBlockWatcherConfigKeys = [
                     validator: attestor,
                     amount: this.config.slashAttestDescendantOfInvalidPenalty,
                     offenseType: OffenseType.ATTESTED_DESCENDANT_OF_INVALID,
-                    epochOrSlot: BigInt(SlotNumber(block.slotNumber))
+                    epochOrSlot: BigInt(SlotNumber(checkpoint.slotNumber))
                 })));
         }
     }
     slashProposer(validationResult) {
-        const { reason, block } = validationResult;
-        const blockNumber = block.blockNumber;
-        const slot = SlotNumber(block.slotNumber);
-        const proposer = this.epochCache.getProposerFromEpochCommittee(validationResult, slot);
+        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 block ${blockNumber} at slot ${slot}`);
+            this.log.warn(`No proposer found for checkpoint ${checkpointNumber} at slot ${slot}`);
             return;
         }
         const offense = this.getOffenseFromInvalidationReason(reason);
@@ -104,8 +110,8 @@ const AttestationsBlockWatcherConfigKeys = [
             offenseType: offense,
             epochOrSlot: BigInt(slot)
         };
-        this.log.info(`Want to slash proposer of block ${blockNumber} due to ${reason}`, {
-            ...block,
+        this.log.info(`Want to slash proposer of checkpoint ${checkpointNumber} due to ${reason}`, {
+            ...checkpoint,
             ...args
         });
         this.emit(WANT_TO_SLASH_EVENT, [
@@ -125,10 +131,10 @@ const AttestationsBlockWatcherConfigKeys = [
                 }
         }
     }
-    addInvalidBlock(block) {
-        this.invalidArchiveRoots.add(block.archive.toString());
+    addInvalidCheckpoint(checkpoint) {
+        this.invalidArchiveRoots.add(checkpoint.archive.toString());
         // Prune old entries if we exceed the maximum
-        if (this.invalidArchiveRoots.size > this.maxInvalidBlocks) {
+        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

@@ -1,7 +1,8 @@
 import { EpochCache } from '@aztec/epoch-cache';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { L2Block, type L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
-import type { IFullNodeBlockBuilder, ITxProvider, MerkleTreeWriteOperations, SlasherConfig } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { ICheckpointsBuilder, ITxProvider, 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]>;
@@ -17,21 +18,22 @@ export declare class EpochPruneWatcher extends EpochPruneWatcher_base implements
     private l1ToL2MessageSource;
     private epochCache;
     private txProvider;
-    private blockBuilder;
+    private checkpointsBuilder;
     private log;
     private boundHandlePruneL2Blocks;
     private penalties;
-    constructor(l2BlockSource: L2BlockSourceEventEmitter, l1ToL2MessageSource: L1ToL2MessageSource, epochCache: EpochCache, txProvider: Pick<ITxProvider, 'getAvailableTxs'>, blockBuilder: IFullNodeBlockBuilder, penalties: EpochPruneWatcherPenalties);
+    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, fork: MerkleTreeWriteOperations): Promise<void>;
+    validateBlocks(blocks: L2Block[], epochNumber: EpochNumber): Promise<void>;
+    private validateCheckpoint;
+    private validateBlockInCheckpoint;
     private getValidatorsForEpoch;
     private validatorsToSlashingArgs;
 }
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2hfcHJ1bmVfd2F0Y2hlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dhdGNoZXJzL2Vwb2NoX3BydW5lX3dhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBSWhELE9BQU8sRUFFTCxPQUFPLEVBRVAsS0FBSyx5QkFBeUIsRUFFL0IsTUFBTSxxQkFBcUIsQ0FBQztBQUU3QixPQUFPLEtBQUssRUFDVixxQkFBcUIsRUFDckIsV0FBVyxFQUNYLHlCQUF5QixFQUN6QixhQUFhLEVBQ2QsTUFBTSxpQ0FBaUMsQ0FBQztBQUN6QyxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBV25FLE9BQU8sRUFBNkMsS0FBSyxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFN0csUUFBQSxNQUFNLG9DQUFvQywrREFBZ0UsQ0FBQztBQUUzRyxLQUFLLDBCQUEwQixHQUFHLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQyxPQUFPLG9DQUFvQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQzs7QUFFN0c7Ozs7O0dBS0c7QUFDSCxxQkFBYSxpQkFBa0IsU0FBUSxzQkFBMkMsWUFBVyxPQUFPO0lBU2hHLE9BQU8sQ0FBQyxhQUFhO0lBQ3JCLE9BQU8sQ0FBQyxtQkFBbUI7SUFDM0IsT0FBTyxDQUFDLFVBQVU7SUFDbEIsT0FBTyxDQUFDLFVBQVU7SUFDbEIsT0FBTyxDQUFDLFlBQVk7SUFadEIsT0FBTyxDQUFDLEdBQUcsQ0FBK0M7SUFHMUQsT0FBTyxDQUFDLHdCQUF3QixDQUF1QztJQUV2RSxPQUFPLENBQUMsU0FBUyxDQUE2QjtJQUU5QyxZQUNVLGFBQWEsRUFBRSx5QkFBeUIsRUFDeEMsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQ3hDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFVBQVUsRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLGlCQUFpQixDQUFDLEVBQ2hELFlBQVksRUFBRSxxQkFBcUIsRUFDM0MsU0FBUyxFQUFFLDBCQUEwQixFQU90QztJQUVNLEtBQUssa0JBR1g7SUFFTSxJQUFJLGtCQUdWO0lBRU0sWUFBWSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsYUFBYSxDQUFDLEdBQUcsSUFBSSxDQUd4RDtJQUVELE9BQU8sQ0FBQyxtQkFBbUI7WUFPYixpQkFBaUI7WUFXakIsb0JBQW9CO0lBd0JyQixjQUFjLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FZNUQ7SUFFWSxhQUFhLENBQUMsV0FBVyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUseUJBQXlCLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQThCL0Y7WUFFYSxxQkFBcUI7SUFTbkMsT0FBTyxDQUFDLHdCQUF3QjtDQWdCakMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2hfcHJ1bmVfd2F0Y2hlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dhdGNoZXJzL2Vwb2NoX3BydW5lX3dhdGNoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2hELE9BQU8sRUFBZSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUkzRSxPQUFPLEVBRUwsT0FBTyxFQUNQLEtBQUsseUJBQXlCLEVBRy9CLE1BQU0scUJBQXFCLENBQUM7QUFFN0IsT0FBTyxLQUFLLEVBRVYsbUJBQW1CLEVBQ25CLFdBQVcsRUFFWCxhQUFhLEVBQ2QsTUFBTSxpQ0FBaUMsQ0FBQztBQUN6QyxPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBNEIsTUFBTSx5QkFBeUIsQ0FBQztBQVk3RixPQUFPLEVBQTZDLEtBQUssT0FBTyxFQUFFLEtBQUssY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTdHLFFBQUEsTUFBTSxvQ0FBb0MsK0RBQWdFLENBQUM7QUFFM0csS0FBSywwQkFBMEIsR0FBRyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUMsT0FBTyxvQ0FBb0MsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7O0FBRTdHOzs7OztHQUtHO0FBQ0gscUJBQWEsaUJBQWtCLFNBQVEsc0JBQTJDLFlBQVcsT0FBTztJQVNoRyxPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsbUJBQW1CO0lBQzNCLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxrQkFBa0I7SUFaNUIsT0FBTyxDQUFDLEdBQUcsQ0FBK0M7SUFHMUQsT0FBTyxDQUFDLHdCQUF3QixDQUF1QztJQUV2RSxPQUFPLENBQUMsU0FBUyxDQUE2QjtJQUU5QyxZQUNVLGFBQWEsRUFBRSx5QkFBeUIsRUFDeEMsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQ3hDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFVBQVUsRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLGlCQUFpQixDQUFDLEVBQ2hELGtCQUFrQixFQUFFLG1CQUFtQixFQUMvQyxTQUFTLEVBQUUsMEJBQTBCLEVBT3RDO0lBRU0sS0FBSyxrQkFHWDtJQUVNLElBQUksa0JBR1Y7SUFFTSxZQUFZLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxhQUFhLENBQUMsR0FBRyxJQUFJLENBR3hEO0lBRUQsT0FBTyxDQUFDLG1CQUFtQjtZQU9iLGlCQUFpQjtZQVdqQixvQkFBb0I7SUF3QnJCLGNBQWMsQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLEVBQUUsV0FBVyxFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBK0J0RjtZQUVhLGtCQUFrQjtZQXdDbEIseUJBQXlCO1lBOEJ6QixxQkFBcUI7SUFTbkMsT0FBTyxDQUFDLHdCQUF3QjtDQWdCakMifQ==

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

@@ -1 +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;AAIhD,OAAO,EAEL,OAAO,EAEP,KAAK,yBAAyB,EAE/B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,qBAAqB,EACrB,WAAW,EACX,yBAAyB,EACzB,aAAa,EACd,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAWnE,OAAO,EAA6C,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7G,QAAA,MAAM,oCAAoC,+DAAgE,CAAC;AAE3G,KAAK,0BAA0B,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,oCAAoC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;;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,YAAY;IAZtB,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,YAAY,EAAE,qBAAqB,EAC3C,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,CAY5D;IAEY,aAAa,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8B/F;YAEa,qBAAqB;IASnC,OAAO,CAAC,wBAAwB;CAgBjC"}
+{"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;AAChD,OAAO,EAAe,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAI3E,OAAO,EAEL,OAAO,EACP,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAEV,mBAAmB,EACnB,WAAW,EAEX,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,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BtF;YAEa,kBAAkB;YAwClB,yBAAyB;YA8BzB,qBAAqB;IASnC,OAAO,CAAC,wBAAwB;CAgBjC"}

package/dest/watchers/epoch_prune_watcher.js

@@ -1,7 +1,9 @@
-import { merge, pick } from '@aztec/foundation/collection';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { chunkBy, merge, pick } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { L2BlockSourceEvents } from '@aztec/stdlib/block';
 import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { computeCheckpointOutHash } from '@aztec/stdlib/messaging';
 import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
 import { ReExFailedTxsError, ReExStateMismatchError, TransactionsNotAvailableError, ValidatorError } from '@aztec/stdlib/validators';
 import EventEmitter from 'node:events';
@@ -20,22 +22,22 @@ const EpochPruneWatcherPenaltiesConfigKeys = [
     l1ToL2MessageSource;
     epochCache;
     txProvider;
-    blockBuilder;
+    checkpointsBuilder;
     log;
     // Store bound function reference for proper listener removal
     boundHandlePruneL2Blocks;
     penalties;
-    constructor(l2BlockSource, l1ToL2MessageSource, epochCache, txProvider, blockBuilder, penalties){
-        super(), this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.epochCache = epochCache, this.txProvider = txProvider, this.blockBuilder = blockBuilder, this.log = createLogger('epoch-prune-watcher'), this.boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
+    constructor(l2BlockSource, l1ToL2MessageSource, epochCache, txProvider, checkpointsBuilder, penalties){
+        super(), this.l2BlockSource = l2BlockSource, this.l1ToL2MessageSource = l1ToL2MessageSource, this.epochCache = epochCache, this.txProvider = txProvider, this.checkpointsBuilder = checkpointsBuilder, this.log = createLogger('epoch-prune-watcher'), this.boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
         this.penalties = pick(penalties, ...EpochPruneWatcherPenaltiesConfigKeys);
         this.log.verbose(`EpochPruneWatcher initialized with penalties: valid epoch pruned=${penalties.slashPrunePenalty} data withholding=${penalties.slashDataWithholdingPenalty}`);
     }
     start() {
-        this.l2BlockSource.on(L2BlockSourceEvents.L2PruneDetected, this.boundHandlePruneL2Blocks);
+        this.l2BlockSource.events.on(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
         return Promise.resolve();
     }
     stop() {
-        this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.boundHandlePruneL2Blocks);
+        this.l2BlockSource.events.removeListener(L2BlockSourceEvents.L2PruneUnproven, this.boundHandlePruneL2Blocks);
         return Promise.resolve();
     }
     updateConfig(config) {
@@ -61,11 +63,11 @@ const EpochPruneWatcherPenaltiesConfigKeys = [
     async processPruneL2Blocks(blocks, epochNumber) {
         try {
             const l1Constants = this.epochCache.getL1Constants();
-            const epochBlocks = blocks.filter((b)=>getEpochAtSlot(b.slot, l1Constants) === epochNumber);
+            const epochBlocks = blocks.filter((b)=>getEpochAtSlot(b.header.getSlot(), l1Constants) === epochNumber);
             this.log.info(`Detected chain prune. Validating epoch ${epochNumber} with blocks ${epochBlocks[0]?.number} to ${epochBlocks[epochBlocks.length - 1]?.number}.`, {
                 blocks: epochBlocks.map((b)=>b.toBlockInfo())
             });
-            await this.validateBlocks(epochBlocks);
+            await this.validateBlocks(epochBlocks, epochNumber);
             this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
             await this.emitSlashForEpoch(OffenseType.VALID_EPOCH_PRUNED, epochNumber);
         } catch (error) {
@@ -79,20 +81,59 @@ const EpochPruneWatcherPenaltiesConfigKeys = [
             }
         }
     }
-    async validateBlocks(blocks) {
+    async validateBlocks(blocks, epochNumber) {
         if (blocks.length === 0) {
             return;
         }
-        const fork = await this.blockBuilder.getFork(blocks[0].header.globalVariables.blockNumber - 1);
+        // Sort blocks by block number and group by checkpoint
+        const sortedBlocks = [
+            ...blocks
+        ].sort((a, b)=>a.number - b.number);
+        const blocksByCheckpoint = chunkBy(sortedBlocks, (b)=>b.checkpointNumber);
+        // Get prior checkpoints in the epoch (in case this was a partial prune) to extract the out hashes
+        const priorCheckpointOutHashes = (await this.l2BlockSource.getCheckpointsDataForEpoch(epochNumber)).filter((c)=>c.checkpointNumber < sortedBlocks[0].checkpointNumber).map((c)=>c.checkpointOutHash);
+        let previousCheckpointOutHashes = [
+            ...priorCheckpointOutHashes
+        ];
+        const fork = await this.checkpointsBuilder.getFork(BlockNumber(sortedBlocks[0].header.globalVariables.blockNumber - 1));
         try {
-            for (const block of blocks){
-                await this.validateBlock(block, fork);
+            for (const checkpointBlocks of blocksByCheckpoint){
+                await this.validateCheckpoint(checkpointBlocks, previousCheckpointOutHashes, fork);
+                // Compute checkpoint out hash from all blocks in this checkpoint
+                const checkpointOutHash = computeCheckpointOutHash(checkpointBlocks.map((b)=>b.body.txEffects.map((tx)=>tx.l2ToL1Msgs)));
+                previousCheckpointOutHashes = [
+                    ...previousCheckpointOutHashes,
+                    checkpointOutHash
+                ];
             }
         } finally{
             await fork.close();
         }
     }
-    async validateBlock(blockFromL1, fork) {
+    async validateCheckpoint(checkpointBlocks, previousCheckpointOutHashes, fork) {
+        const checkpointNumber = checkpointBlocks[0].checkpointNumber;
+        this.log.debug(`Validating pruned checkpoint ${checkpointNumber} with ${checkpointBlocks.length} blocks`);
+        // Get L1ToL2Messages once for the entire checkpoint
+        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+        // Build checkpoint constants from first block's global variables
+        const gv = checkpointBlocks[0].header.globalVariables;
+        const constants = {
+            chainId: gv.chainId,
+            version: gv.version,
+            slotNumber: gv.slotNumber,
+            timestamp: gv.timestamp,
+            coinbase: gv.coinbase,
+            feeRecipient: gv.feeRecipient,
+            gasFees: gv.gasFees
+        };
+        // Start checkpoint builder once for all blocks in this checkpoint
+        const checkpointBuilder = await this.checkpointsBuilder.startCheckpoint(checkpointNumber, constants, 0n, l1ToL2Messages, previousCheckpointOutHashes, fork, this.log.getBindings());
+        // Validate all blocks in the checkpoint sequentially
+        for (const block of checkpointBlocks){
+            await this.validateBlockInCheckpoint(block, checkpointBuilder);
+        }
+    }
+    async validateBlockInCheckpoint(blockFromL1, checkpointBuilder) {
         this.log.debug(`Validating pruned block ${blockFromL1.header.globalVariables.blockNumber}`);
         const txHashes = blockFromL1.body.txEffects.map((txEffect)=>txEffect.txHash);
         // We load txs from the mempool directly, since the TxCollector running in the background has already been
@@ -102,8 +143,8 @@ const EpochPruneWatcherPenaltiesConfigKeys = [
         if (missingTxs && missingTxs.length > 0) {
             throw new TransactionsNotAvailableError(missingTxs);
         }
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockFromL1.number);
-        const { block, failedTxs, numTxs } = await this.blockBuilder.buildBlock(txs, l1ToL2Messages, blockFromL1.header.globalVariables, {}, fork);
+        const gv = blockFromL1.header.globalVariables;
+        const { block, failedTxs, numTxs } = await checkpointBuilder.buildBlock(txs, gv.blockNumber, gv.timestamp, {});
         if (numTxs !== txs.length) {
             // This should be detected by state mismatch, but this makes it easier to debug.
             throw new ValidatorError(`Built block with ${numTxs} txs, expected ${txs.length}`);

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@aztec/slasher",
-  "version": "0.0.1-commit.fce3e4f",
+  "version": "0.0.1-commit.ff7989d6c",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
     "./config": "./dest/config.js"
   },
   "inherits": [
-    "../package.common.json"
+    "../package.common.json",
+    "./package.local.json"
   ],
   "scripts": {
-    "build": "yarn clean && tsgo -b",
-    "build:dev": "tsgo -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "bb": "node --no-warnings ./dest/bb/index.js",
-    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "generate": "./scripts/generate.sh"
   },
   "jest": {
     "moduleNameMapper": {
@@ -54,25 +56,25 @@
     ]
   },
   "dependencies": {
-    "@aztec/epoch-cache": "0.0.1-commit.fce3e4f",
-    "@aztec/ethereum": "0.0.1-commit.fce3e4f",
-    "@aztec/foundation": "0.0.1-commit.fce3e4f",
-    "@aztec/kv-store": "0.0.1-commit.fce3e4f",
-    "@aztec/l1-artifacts": "0.0.1-commit.fce3e4f",
-    "@aztec/stdlib": "0.0.1-commit.fce3e4f",
-    "@aztec/telemetry-client": "0.0.1-commit.fce3e4f",
+    "@aztec/epoch-cache": "0.0.1-commit.ff7989d6c",
+    "@aztec/ethereum": "0.0.1-commit.ff7989d6c",
+    "@aztec/foundation": "0.0.1-commit.ff7989d6c",
+    "@aztec/kv-store": "0.0.1-commit.ff7989d6c",
+    "@aztec/l1-artifacts": "0.0.1-commit.ff7989d6c",
+    "@aztec/stdlib": "0.0.1-commit.ff7989d6c",
+    "@aztec/telemetry-client": "0.0.1-commit.ff7989d6c",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@aztec/aztec.js": "0.0.1-commit.fce3e4f",
+    "@aztec/aztec.js": "0.0.1-commit.ff7989d6c",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",
     "@types/source-map-support": "^0.5.10",
-    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",

package/src/config.ts

@@ -1,4 +1,3 @@
-import { DefaultL1ContractsConfig } from '@aztec/ethereum';
 import type { ConfigMappingsType } from '@aztec/foundation/config';
 import {
   bigintConfigHelper,
@@ -9,27 +8,31 @@ import {
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
 
+import { slasherDefaultEnv } from './generated/slasher-defaults.js';
+
 export type { SlasherConfig };
 
 export const DefaultSlasherConfig: SlasherConfig = {
   slashOverridePayload: undefined,
-  slashMinPenaltyPercentage: 0.5, // 50% of penalty
-  slashMaxPenaltyPercentage: 2.0, //2x of penalty
+  slashMinPenaltyPercentage: slasherDefaultEnv.SLASH_MIN_PENALTY_PERCENTAGE,
+  slashMaxPenaltyPercentage: slasherDefaultEnv.SLASH_MAX_PENALTY_PERCENTAGE,
   slashValidatorsAlways: [], // Empty by default
   slashValidatorsNever: [], // Empty by default
-  slashPrunePenalty: DefaultL1ContractsConfig.slashAmountSmall,
-  slashDataWithholdingPenalty: DefaultL1ContractsConfig.slashAmountSmall,
-  slashInactivityTargetPercentage: 0.9,
-  slashInactivityConsecutiveEpochThreshold: 1, // Default to 1 for backward compatibility
-  slashBroadcastedInvalidBlockPenalty: DefaultL1ContractsConfig.slashAmountSmall,
-  slashInactivityPenalty: DefaultL1ContractsConfig.slashAmountSmall,
-  slashProposeInvalidAttestationsPenalty: DefaultL1ContractsConfig.slashAmountSmall,
-  slashAttestDescendantOfInvalidPenalty: DefaultL1ContractsConfig.slashAmountSmall,
-  slashUnknownPenalty: DefaultL1ContractsConfig.slashAmountSmall,
-  slashOffenseExpirationRounds: 4,
-  slashMaxPayloadSize: 50,
-  slashGracePeriodL2Slots: 0,
-  slashExecuteRoundsLookBack: 4,
+  slashPrunePenalty: BigInt(slasherDefaultEnv.SLASH_PRUNE_PENALTY),
+  slashDataWithholdingPenalty: BigInt(slasherDefaultEnv.SLASH_DATA_WITHHOLDING_PENALTY),
+  slashInactivityTargetPercentage: slasherDefaultEnv.SLASH_INACTIVITY_TARGET_PERCENTAGE,
+  slashInactivityConsecutiveEpochThreshold: slasherDefaultEnv.SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD,
+  slashBroadcastedInvalidBlockPenalty: BigInt(slasherDefaultEnv.SLASH_INVALID_BLOCK_PENALTY),
+  slashDuplicateProposalPenalty: BigInt(slasherDefaultEnv.SLASH_DUPLICATE_PROPOSAL_PENALTY),
+  slashDuplicateAttestationPenalty: BigInt(slasherDefaultEnv.SLASH_DUPLICATE_ATTESTATION_PENALTY),
+  slashInactivityPenalty: BigInt(slasherDefaultEnv.SLASH_INACTIVITY_PENALTY),
+  slashProposeInvalidAttestationsPenalty: BigInt(slasherDefaultEnv.SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY),
+  slashAttestDescendantOfInvalidPenalty: BigInt(slasherDefaultEnv.SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY),
+  slashUnknownPenalty: BigInt(slasherDefaultEnv.SLASH_UNKNOWN_PENALTY),
+  slashOffenseExpirationRounds: slasherDefaultEnv.SLASH_OFFENSE_EXPIRATION_ROUNDS,
+  slashMaxPayloadSize: slasherDefaultEnv.SLASH_MAX_PAYLOAD_SIZE,
+  slashGracePeriodL2Slots: slasherDefaultEnv.SLASH_GRACE_PERIOD_L2_SLOTS,
+  slashExecuteRoundsLookBack: slasherDefaultEnv.SLASH_EXECUTE_ROUNDS_LOOK_BACK,
   slashSelfAllowed: false,
 };
 
@@ -87,6 +90,17 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
     description: 'Penalty amount for slashing a validator for an invalid block proposed via p2p.',
     ...bigintConfigHelper(DefaultSlasherConfig.slashBroadcastedInvalidBlockPenalty),
   },
+  slashDuplicateProposalPenalty: {
+    env: 'SLASH_DUPLICATE_PROPOSAL_PENALTY',
+    description: 'Penalty amount for slashing a validator for sending duplicate proposals.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashDuplicateProposalPenalty),
+  },
+  slashDuplicateAttestationPenalty: {
+    env: 'SLASH_DUPLICATE_ATTESTATION_PENALTY',
+    description:
+      'Penalty amount for slashing a validator for signing attestations for different proposals at the same slot.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashDuplicateAttestationPenalty),
+  },
   slashInactivityTargetPercentage: {
     env: 'SLASH_INACTIVITY_TARGET_PERCENTAGE',
     description:

package/src/empire_slasher_client.ts

@@ -1,10 +1,9 @@
-import { EmpireSlashingProposerContract, RollupContract, SlasherContract } from '@aztec/ethereum';
+import { EmpireSlashingProposerContract, RollupContract, SlasherContract } from '@aztec/ethereum/contracts';
 import { sumBigint } from '@aztec/foundation/bigint';
 import { SlotNumber } from '@aztec/foundation/branded-types';
 import { compactArray, filterAsync, maxBy, pick } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { sleep } from '@aztec/foundation/sleep';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
@@ -196,13 +195,6 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
     this.roundMonitor.stop();
     await this.offensesCollector.stop();
 
-    // Viem calls eth_uninstallFilter under the hood when uninstalling event watchers, but these calls are not awaited,
-    // meaning that any error that happens during the uninstallation will not be caught. This causes errors during jest teardowns,
-    // where we stop anvil after all other processes are stopped, so sometimes the eth_uninstallFilter call fails because anvil
-    // is already stopped. We add a sleep here to give the uninstallation some time to complete, but the proper fix is for
-    // viem to await the eth_uninstallFilter calls, or to catch any errors that happen during the uninstallation.
-    // See https://github.com/wevm/viem/issues/3714.
-    await sleep(2000);
     this.log.info('Empire Slasher client stopped');
   }
 

package/src/factory/create_facade.ts

@@ -1,6 +1,7 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import type { L1ReaderConfig, ViemClient } from '@aztec/ethereum';
 import { RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import type { ViemClient } from '@aztec/ethereum/types';
 import { unique } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
@@ -30,7 +31,7 @@ export async function createSlasherFacade(
     throw new Error('Cannot initialize SlasherClient without a Rollup address');
   }
 
-  const kvStore = await createStore('slasher', SCHEMA_VERSION, config, createLogger('slasher:lmdb'));
+  const kvStore = await createStore('slasher', SCHEMA_VERSION, config, logger.getBindings());
   const rollup = new RollupContract(l1Client, l1Contracts.rollupAddress);
 
   const slashValidatorsNever = config.slashSelfAllowed

package/src/factory/create_implementation.ts

@@ -1,10 +1,10 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import type { ViemClient } from '@aztec/ethereum';
 import {
   EmpireSlashingProposerContract,
   RollupContract,
   TallySlashingProposerContract,
 } from '@aztec/ethereum/contracts';
+import type { ViemClient } from '@aztec/ethereum/types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';

package/src/factory/get_settings.ts

@@ -1,4 +1,4 @@
-import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
+import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
 
 import type { TallySlasherSettings } from '../tally_slasher_client.js';
 

package/src/generated/slasher-defaults.ts

@@ -0,0 +1,23 @@
+// 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: 50,
+  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: 10000000000000000000,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
+  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
+} as const;

package/src/slasher_client_facade.ts

@@ -1,6 +1,6 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import type { ViemClient } from '@aztec/ethereum';
 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 { createLogger } from '@aztec/foundation/log';

package/src/stores/offenses_store.ts

@@ -76,9 +76,11 @@ export class SlasherOffensesStore {
   /** Adds a new offense (defaults to pending, but will be slashed if markAsSlashed had been called for it) */
   public async addPendingOffense(offense: Offense): Promise<void> {
     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);
+    await this.kvStore.transactionAsync(async () => {
+      await this.offenses.set(key, serializeOffense(offense));
+      await this.roundsOffenses.set(this.getRoundKey(round), key);
+    });
     this.log.trace(`Adding pending offense ${key} for round ${round}`);
   }
 

package/src/stores/payloads_store.ts

@@ -118,10 +118,13 @@ export class SlasherPayloadsStore {
 
   public async incrementPayloadVotes(payloadAddress: EthAddress, round: bigint): Promise<bigint> {
     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;
+    let newVotes: bigint;
+    await this.kvStore.transactionAsync(async () => {
+      const currentVotes = (await this.roundPayloadVotes.getAsync(key)) || 0n;
+      newVotes = currentVotes + 1n;
+      await this.roundPayloadVotes.set(key, newVotes);
+    });
+    return newVotes!;
   }
 
   public async addPayload(payload: SlashPayloadRound): Promise<void> {