@aztec/slasher 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/dest/watchers/epoch_prune_watcher.js

@@ -1,9 +1,16 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { L2BlockSourceEvents } from '@aztec/stdlib/block';
-import { OffenseType } from '@aztec/stdlib/slashing';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
 import { ReExFailedTxsError, ReExStateMismatchError, TransactionsNotAvailableError, ValidatorError } from '@aztec/stdlib/validators';
 import EventEmitter from 'node:events';
 import { WANT_TO_SLASH_EVENT } from '../watcher.js';
+const EpochPruneWatcherPenaltiesConfigKeys = [
+    'slashPrunePenalty',
+    'slashDataWithholdingPenalty'
+];
 /**
  * This watcher is responsible for detecting chain prunes and creating slashing arguments for the committee.
  * It only wants to slash if:
@@ -15,12 +22,13 @@ import { WANT_TO_SLASH_EVENT } from '../watcher.js';
     epochCache;
     txProvider;
     blockBuilder;
-    penalties;
     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.penalties = penalties, this.log = createLogger('epoch-prune-watcher'), this.boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
+        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);
+        this.penalties = pick(penalties, ...EpochPruneWatcherPenaltiesConfigKeys);
         this.log.verbose(`EpochPruneWatcher initialized with penalties: valid epoch pruned=${penalties.slashPrunePenalty} data withholding=${penalties.slashDataWithholdingPenalty}`);
     }
     start() {
@@ -31,50 +39,52 @@ import { WANT_TO_SLASH_EVENT } from '../watcher.js';
         this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.boundHandlePruneL2Blocks);
         return Promise.resolve();
     }
+    updateConfig(config) {
+        this.penalties = merge(this.penalties, pick(config, ...EpochPruneWatcherPenaltiesConfigKeys));
+        this.log.verbose('EpochPruneWatcher config updated', this.penalties);
+    }
     handlePruneL2Blocks(event) {
         const { blocks, epochNumber } = event;
-        this.log.info(`Detected chain prune. Validating epoch ${epochNumber}`);
-        this.validateBlocks(blocks).then(async ()=>{
+        void this.processPruneL2Blocks(blocks, epochNumber).catch((err)=>this.log.error('Error processing pruned L2 blocks', err, {
+                epochNumber
+            }));
+    }
+    async emitSlashForEpoch(offense, epochNumber) {
+        const validators = await this.getValidatorsForEpoch(epochNumber);
+        if (validators.length === 0) {
+            this.log.warn(`No validators found for epoch ${epochNumber} (cannot slash for ${getOffenseTypeName(offense)})`);
+            return;
+        }
+        const args = this.validatorsToSlashingArgs(validators, offense, epochNumber);
+        this.log.verbose(`Created slash for ${getOffenseTypeName(offense)} at epoch ${epochNumber}`, args);
+        this.emit(WANT_TO_SLASH_EVENT, args);
+    }
+    async processPruneL2Blocks(blocks, epochNumber) {
+        try {
+            const l1Constants = this.epochCache.getL1Constants();
+            const epochBlocks = blocks.filter((b)=>getEpochAtSlot(b.slot, l1Constants) === epochNumber);
+            this.log.info(`Detected chain prune. Validating epoch ${epochNumber} with blocks ${epochBlocks[0]?.number} to ${epochBlocks[epochBlocks.length - 1]?.number}.`, {
+                blocks: epochBlocks.map((b)=>b.toBlockInfo())
+            });
+            await this.validateBlocks(epochBlocks);
             this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
-            const validators = await this.getValidatorsForEpoch(epochNumber);
-            // need to specify return type to be able to return offense as undefined later on
-            const result = {
-                validators,
-                offense: OffenseType.VALID_EPOCH_PRUNED
-            };
-            return result;
-        }).catch(async (error)=>{
+            await this.emitSlashForEpoch(OffenseType.VALID_EPOCH_PRUNED, epochNumber);
+        } catch (error) {
             if (error instanceof TransactionsNotAvailableError) {
-                this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, error);
-                const validators = await this.getValidatorsForEpoch(epochNumber);
-                return {
-                    validators,
-                    offense: OffenseType.DATA_WITHHOLDING
-                };
+                this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, {
+                    message: error.message
+                });
+                await this.emitSlashForEpoch(OffenseType.DATA_WITHHOLDING, epochNumber);
             } else {
                 this.log.error(`Error while validating pruned epoch ${epochNumber}. Will not want to slash.`, error);
-                return {
-                    validators: [],
-                    offense: undefined
-                };
             }
-        }).then(({ validators, offense })=>{
-            if (validators.length === 0 || offense === undefined) {
-                return;
-            }
-            const args = this.validatorsToSlashingArgs(validators, offense, BigInt(epochNumber));
-            this.log.info(`Slash for epoch ${epochNumber} created`, args);
-            this.emit(WANT_TO_SLASH_EVENT, args);
-        }).catch((error)=>{
-            // This can happen if we fail to get the validators for the epoch.
-            this.log.error('Error while creating slash for epoch', error);
-        });
+        }
     }
     async validateBlocks(blocks) {
         if (blocks.length === 0) {
             return;
         }
-        const fork = await this.blockBuilder.getFork(blocks[0].header.globalVariables.blockNumber - 1);
+        const fork = await this.blockBuilder.getFork(BlockNumber(blocks[0].header.globalVariables.blockNumber - 1));
         try {
             for (const block of blocks){
                 await this.validateBlock(block, fork);
@@ -93,7 +103,8 @@ import { WANT_TO_SLASH_EVENT } from '../watcher.js';
         if (missingTxs && missingTxs.length > 0) {
             throw new TransactionsNotAvailableError(missingTxs);
         }
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockFromL1.number);
+        const checkpointNumber = CheckpointNumber.fromBlockNumber(blockFromL1.number);
+        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
         const { block, failedTxs, numTxs } = await this.blockBuilder.buildBlock(txs, l1ToL2Messages, blockFromL1.header.globalVariables, {}, fork);
         if (numTxs !== txs.length) {
             // This should be detected by state mismatch, but this makes it easier to debug.
@@ -120,7 +131,7 @@ import { WANT_TO_SLASH_EVENT } from '../watcher.js';
                 validator: v,
                 amount: penalty,
                 offenseType,
-                epochOrSlot
+                epochOrSlot: BigInt(epochOrSlot)
             }));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/slasher",
-  "version": "4.0.0-nightly.20250907",
+  "version": "4.0.0-nightly.20260108",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -10,8 +10,8 @@
     "../package.common.json"
   ],
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -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}"
@@ -54,24 +54,25 @@
     ]
   },
   "dependencies": {
-    "@aztec/epoch-cache": "4.0.0-nightly.20250907",
-    "@aztec/ethereum": "4.0.0-nightly.20250907",
-    "@aztec/foundation": "4.0.0-nightly.20250907",
-    "@aztec/kv-store": "4.0.0-nightly.20250907",
-    "@aztec/l1-artifacts": "4.0.0-nightly.20250907",
-    "@aztec/stdlib": "4.0.0-nightly.20250907",
-    "@aztec/telemetry-client": "4.0.0-nightly.20250907",
+    "@aztec/epoch-cache": "4.0.0-nightly.20260108",
+    "@aztec/ethereum": "4.0.0-nightly.20260108",
+    "@aztec/foundation": "4.0.0-nightly.20260108",
+    "@aztec/kv-store": "4.0.0-nightly.20260108",
+    "@aztec/l1-artifacts": "4.0.0-nightly.20260108",
+    "@aztec/stdlib": "4.0.0-nightly.20260108",
+    "@aztec/telemetry-client": "4.0.0-nightly.20260108",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
-    "viem": "2.23.7",
+    "viem": "npm:@aztec/viem@2.38.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@aztec/aztec.js": "4.0.0-nightly.20250907",
+    "@aztec/aztec.js": "4.0.0-nightly.20260108",
     "@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",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",

package/src/config.ts

@@ -1,4 +1,4 @@
-import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
 import type { ConfigMappingsType } from '@aztec/foundation/config';
 import {
   bigintConfigHelper,
@@ -29,6 +29,7 @@ export const DefaultSlasherConfig: SlasherConfig = {
   slashOffenseExpirationRounds: 4,
   slashMaxPayloadSize: 50,
   slashGracePeriodL2Slots: 0,
+  slashExecuteRoundsLookBack: 4,
   slashSelfAllowed: false,
 };
 
@@ -83,7 +84,7 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
   },
   slashBroadcastedInvalidBlockPenalty: {
     env: 'SLASH_INVALID_BLOCK_PENALTY',
-    description: 'Penalty amount for slashing a validator for an invalid block.',
+    description: 'Penalty amount for slashing a validator for an invalid block proposed via p2p.',
     ...bigintConfigHelper(DefaultSlasherConfig.slashBroadcastedInvalidBlockPenalty),
   },
   slashInactivityTargetPercentage: {
@@ -144,6 +145,11 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
     env: 'SLASH_GRACE_PERIOD_L2_SLOTS',
     ...numberConfigHelper(DefaultSlasherConfig.slashGracePeriodL2Slots),
   },
+  slashExecuteRoundsLookBack: {
+    env: 'SLASH_EXECUTE_ROUNDS_LOOK_BACK',
+    description: 'How many rounds to look back when searching for a round to execute.',
+    ...numberConfigHelper(DefaultSlasherConfig.slashExecuteRoundsLookBack),
+  },
   slashSelfAllowed: {
     description: 'Whether to allow slashes to own validators',
     ...booleanConfigHelper(DefaultSlasherConfig.slashSelfAllowed),

package/src/empire_slasher_client.ts

@@ -1,5 +1,6 @@
-import { EmpireSlashingProposerContract, RollupContract } 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';
@@ -121,6 +122,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
     private settings: EmpireSlasherSettings,
     private slashFactoryContract: SlashFactoryContract,
     private slashingProposer: EmpireSlashingProposerContract,
+    private slasher: SlasherContract,
     private rollup: RollupContract,
     watchers: Watcher[],
     private dateProvider: DateProvider,
@@ -368,7 +370,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
    * @param slotNumber - The current slot number
    * @returns The actions to take
    */
-  public async getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  public async getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     const [executeAction, proposePayloadActions] = await Promise.all([
       this.getExecutePayloadAction(slotNumber),
       this.getProposePayloadActions(slotNumber),
@@ -378,7 +380,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
   }
 
   /** Returns an execute payload action if there are any payloads ready to be executed */
-  protected async getExecutePayloadAction(slotNumber: bigint): Promise<ProposerSlashAction | undefined> {
+  protected async getExecutePayloadAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined> {
     const { round } = this.roundMonitor.getRoundForSlot(slotNumber);
     const toRemove: PayloadWithRound[] = [];
 
@@ -403,12 +405,17 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
         continue;
       }
 
+      // Check if slashing is enabled at all
+      if (!(await this.slasher.isSlashingEnabled())) {
+        this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`);
+        return undefined;
+      }
+
       // Check if the slash payload is vetoed
-      const slasherContract = await this.rollup.getSlasherContract();
-      const isVetoed = await slasherContract.isPayloadVetoed(payload.payload);
+      const isVetoed = await this.slasher.isPayloadVetoed(payload.payload);
 
       if (isVetoed) {
-        this.log.info(`Payload ${payload.payload} from round ${payload.round} is vetoed, skipping execution`);
+        this.log.info(`Payload ${payload.payload} from round ${payload.round} is vetoed (skipping execution)`);
         toRemove.push(payload);
         continue;
       }
@@ -424,7 +431,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
   }
 
   /** Returns a vote or create payload action based on payload scoring */
-  protected async getProposePayloadActions(slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  protected async getProposePayloadActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     // Compute what round we are in based on the slot number
     const { round, votingSlot } = this.roundMonitor.getRoundForSlot(slotNumber);
     const { slashingRoundSize: roundSize, slashingQuorumSize: quorumSize } = this.settings;
@@ -467,7 +474,7 @@ export class EmpireSlasherClient implements ProposerSlashActionProvider, Slasher
     // Find the best existing payload. We filter out those that have no chance of winning given how many voting
     // slots are left in the round, and then filter by those we agree with.
     const feasiblePayloads = existingPayloads.filter(
-      p => BigInt(quorumSize) - p.votes <= BigInt(roundSize) - votingSlot,
+      p => BigInt(quorumSize) - p.votes <= BigInt(roundSize) - BigInt(votingSlot),
     );
     const requiredOffenses = await this.getPendingUncontroversialOffensesForRound(round);
     const agreedPayloads = await filterAsync(feasiblePayloads, p => this.agreeWithPayload(p, round, requiredOffenses));

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';

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';
@@ -71,6 +71,7 @@ async function createEmpireSlasher(
     l1GenesisTime,
     slotDuration,
     l1StartBlock,
+    slasher,
   ] = await Promise.all([
     slashingProposer.getExecutionDelayInRounds(),
     slashingProposer.getLifetimeInRounds(),
@@ -81,6 +82,7 @@ async function createEmpireSlasher(
     rollup.getL1GenesisTime(),
     rollup.getSlotDuration(),
     rollup.getL1StartBlock(),
+    rollup.getSlasherContract(),
   ]);
 
   const settings: EmpireSlasherSettings = {
@@ -110,6 +112,7 @@ async function createEmpireSlasher(
     settings,
     slashFactoryContract,
     slashingProposer,
+    slasher!,
     rollup,
     watchers,
     dateProvider,
@@ -134,6 +137,7 @@ async function createTallySlasher(
   }
 
   const settings = await getTallySlasherSettings(rollup, slashingProposer);
+  const slasher = await rollup.getSlasherContract();
 
   const offensesStore = new SlasherOffensesStore(kvStore, {
     ...settings,
@@ -144,6 +148,7 @@ async function createTallySlasher(
     config,
     settings,
     slashingProposer,
+    slasher!,
     rollup,
     watchers,
     epochCache,

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/null_slasher_client.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
 
 import type { SlasherConfig } from './config.js';
@@ -30,7 +31,7 @@ export class NullSlasherClient implements SlasherClientInterface {
     this.config = { ...this.config, ...config };
   }
 
-  public getProposerActions(_slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  public getProposerActions(_slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     return Promise.resolve([]);
   }
 

package/src/slash_offenses_collector.ts

@@ -95,10 +95,9 @@ export class SlashOffensesCollector {
    * Clears expired offenses from stores.
    */
   public async handleNewRound(round: bigint) {
-    this.log.verbose(`Clearing expired offenses for new slashing round ${round}`);
     const cleared = await this.offensesStore.clearExpiredOffenses(round);
     if (cleared && cleared > 0) {
-      this.log.verbose(`Cleared ${cleared} expired offenses`);
+      this.log.debug(`Cleared ${cleared} expired offenses for round ${round}`);
     }
   }
 

package/src/slash_round_monitor.ts

@@ -1,3 +1,4 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { Prettify } from '@aztec/foundation/types';
@@ -48,12 +49,12 @@ export class SlashRoundMonitor {
   }
 
   /** Returns the slashing round number and the voting slot within the round based on the L2 chain slot */
-  public getRoundForSlot(slotNumber: bigint): { round: bigint; votingSlot: bigint } {
+  public getRoundForSlot(slotNumber: SlotNumber): { round: bigint; votingSlot: SlotNumber } {
     return getRoundForSlot(slotNumber, this.settings);
   }
 
   /** Returns the current slashing round and voting slot within the round */
-  public getCurrentRound(): { round: bigint; votingSlot: bigint } {
+  public getCurrentRound(): { round: bigint; votingSlot: SlotNumber } {
     const now = this.dateProvider.nowInSeconds();
     const currentSlot = getSlotAtTimestamp(BigInt(now), this.settings);
     return this.getRoundForSlot(currentSlot);

package/src/slasher_client_facade.ts

@@ -1,6 +1,7 @@
 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';
 import { DateProvider } from '@aztec/foundation/timer';
@@ -58,6 +59,7 @@ export class SlasherClientFacade implements SlasherClientInterface {
   public updateConfig(config: Partial<SlasherConfig>): void {
     this.config = { ...this.config, ...config };
     this.client?.updateConfig(config);
+    this.watchers.forEach(watcher => watcher.updateConfig?.(config));
   }
 
   public getSlashPayloads(): Promise<SlashPayloadRound[]> {
@@ -72,7 +74,7 @@ export class SlasherClientFacade implements SlasherClientInterface {
     return this.client?.getPendingOffenses() ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 
-  public getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  public getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     return this.client?.getProposerActions(slotNumber) ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 

package/src/slasher_client_interface.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
 import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
 
@@ -38,7 +39,7 @@ export interface SlasherClientInterface {
    * @param slotNumber - The current slot number
    * @returns The actions to take
    */
-  getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]>;
+  getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
 
   /** Returns the current config */
   getConfig(): SlasherConfig;

package/src/stores/offenses_store.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSet } from '@aztec/kv-store';
 import {
   type Offense,

package/src/tally_slasher_client.ts

@@ -1,6 +1,8 @@
-import { EthAddress } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import { RollupContract, SlasherContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import { maxBigint } from '@aztec/foundation/bigint';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { compactArray, partition, times } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
@@ -45,7 +47,7 @@ export type TallySlasherSettings = Prettify<
 >;
 
 export type TallySlasherClientConfig = SlashOffensesCollectorConfig &
-  Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever'>;
+  Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack'>;
 
 /**
  * The Tally Slasher client is responsible for managing slashable offenses using
@@ -88,6 +90,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     private config: TallySlasherClientConfig,
     private settings: TallySlasherSettings,
     private tallySlashingProposer: TallySlashingProposerContract,
+    private slasher: SlasherContract,
     private rollup: RollupContract,
     watchers: Watcher[],
     private epochCache: EpochCache,
@@ -167,7 +170,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
    * @param slotNumber - The current slot number
    * @returns The actions to take
    */
-  public async getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]> {
+  public async getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
     const [executeAction, voteAction] = await Promise.all([
       this.getExecuteSlashAction(slotNumber),
       this.getVoteOffensesAction(slotNumber),
@@ -176,16 +179,65 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     return compactArray<ProposerSlashAction>([executeAction, voteAction]);
   }
 
-  /** Returns an execute slash action if there are any rounds ready to be executed */
-  protected async getExecuteSlashAction(slotNumber: bigint): Promise<ProposerSlashAction | undefined> {
+  /**
+   * 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 async getExecuteSlashAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined> {
     const { round: currentRound } = this.roundMonitor.getRoundForSlot(slotNumber);
     const slashingExecutionDelayInRounds = BigInt(this.settings.slashingExecutionDelayInRounds);
     const executableRound = currentRound - slashingExecutionDelayInRounds - 1n;
-    if (executableRound < 0n) {
+    const lookBack = BigInt(this.config.slashExecuteRoundsLookBack);
+    const slashingLifetimeInRounds = BigInt(this.settings.slashingLifetimeInRounds);
+
+    // Compute the oldest executable round considering both lookBack and lifetimeInRounds
+    // A round is only executable if currentRound <= round + lifetimeInRounds
+    // So the oldest round we can execute is: currentRound - lifetimeInRounds
+    const oldestByLifetime = maxBigint(0n, currentRound - slashingLifetimeInRounds);
+    const oldestByLookBack = maxBigint(0n, executableRound - lookBack);
+    const oldestExecutableRound = maxBigint(oldestByLifetime, oldestByLookBack);
+
+    // Check if slashing is enabled at all
+    if (!(await this.slasher.isSlashingEnabled())) {
+      this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`);
       return undefined;
     }
 
-    let logData: Record<string, unknown> = { currentRound, executableRound, slotNumber };
+    this.log.debug(`Checking slashing rounds ${oldestExecutableRound} to ${executableRound} to execute`, {
+      slotNumber,
+      currentRound,
+      oldestExecutableRound,
+      oldestByLifetime,
+      oldestByLookBack,
+      executableRound,
+      slashingExecutionDelayInRounds,
+      lookBack,
+      slashingLifetimeInRounds,
+    });
+
+    // Iterate over all rounds, starting from the oldest, until we find one that is executable
+    for (let roundToCheck = oldestExecutableRound; roundToCheck <= executableRound; roundToCheck++) {
+      const action = await this.tryGetRoundExecuteAction(roundToCheck, slotNumber);
+      if (action) {
+        return action;
+      }
+    }
+
+    // And return nothing if none are found
+    return undefined;
+  }
+
+  /**
+   * Checks if a given round is executable and returns an execute-slash action for it if so.
+   * Assumes round number has already been checked against lifetime and execution delay.
+   * @param executableRound - The round to check for execution
+   */
+  private async tryGetRoundExecuteAction(
+    executableRound: bigint,
+    slotNumber: SlotNumber,
+  ): Promise<ProposerSlashAction | undefined> {
+    let logData: Record<string, unknown> = { executableRound, slotNumber };
+    this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
 
     try {
       const roundInfo = await this.tallySlashingProposer.getRound(executableRound);
@@ -193,9 +245,6 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       if (roundInfo.isExecuted) {
         this.log.verbose(`Round ${executableRound} has already been executed`, logData);
         return undefined;
-      } else if (!roundInfo.readyToExecute) {
-        this.log.verbose(`Round ${executableRound} is not ready to execute yet`, logData);
-        return undefined;
       } else if (roundInfo.voteCount === 0n) {
         this.log.debug(`Round ${executableRound} received no votes`, logData);
         return undefined;
@@ -204,6 +253,17 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
         return undefined;
       }
 
+      // Check if round is ready to execute at the given slot
+      const isReadyToExecute = await this.tallySlashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
+      if (!isReadyToExecute) {
+        this.log.warn(
+          `Round ${executableRound} is not ready to execute at slot ${slotNumber} according to contract check`,
+          logData,
+        );
+        return undefined;
+      }
+
+      // Check if the round yields any slashing at all
       const { actions: slashActions, committees } = await this.tallySlashingProposer.getTally(executableRound);
       if (slashActions.length === 0) {
         this.log.verbose(`Round ${executableRound} does not resolve in any slashing`, logData);
@@ -212,8 +272,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
       // Check if the slash payload is vetoed
       const payload = await this.tallySlashingProposer.getPayload(executableRound);
-      const slasherContract = await this.rollup.getSlasherContract();
-      const isVetoed = await slasherContract.isPayloadVetoed(payload.address);
+      const isVetoed = await this.slasher.isPayloadVetoed(payload.address);
       if (isVetoed) {
         this.log.warn(`Round ${executableRound} payload is vetoed (skipping execution)`, {
           payloadAddress: payload.address.toString(),
@@ -239,13 +298,12 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       return { type: 'execute-slash', round: executableRound, committees: slashedCommittees };
     } catch (error) {
       this.log.error(`Error checking round to execute ${executableRound}`, error);
+      return undefined;
     }
-
-    return undefined;
   }
 
   /** Returns a vote action based on offenses from the target round (with offset applied) */
-  protected async getVoteOffensesAction(slotNumber: bigint): Promise<ProposerSlashAction | undefined> {
+  protected async getVoteOffensesAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined> {
     // Compute what round we are in based on the slot number and what round will be slashed
     const { round: currentRound } = this.roundMonitor.getRoundForSlot(slotNumber);
     const slashedRound = this.getSlashedRound(currentRound);
@@ -299,7 +357,12 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
     const committees = await this.collectCommitteesActiveDuringRound(slashedRound);
     const epochsForCommittees = getEpochsForRound(slashedRound, this.settings);
-    const votes = getSlashConsensusVotesFromOffenses(offensesToSlash, committees, epochsForCommittees, this.settings);
+    const votes = getSlashConsensusVotesFromOffenses(
+      offensesToSlash,
+      committees,
+      epochsForCommittees.map(e => BigInt(e)),
+      this.settings,
+    );
     if (votes.every(v => v === 0)) {
       this.log.warn(`Computed votes for offenses are all zero. Skipping vote.`, {
         slotNumber,