@aztec/slasher 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

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": "3.0.0-canary.a9708bd",
+  "version": "3.0.0-devnet.2-patch.1",
   "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": "3.0.0-canary.a9708bd",
-    "@aztec/ethereum": "3.0.0-canary.a9708bd",
-    "@aztec/foundation": "3.0.0-canary.a9708bd",
-    "@aztec/kv-store": "3.0.0-canary.a9708bd",
-    "@aztec/l1-artifacts": "3.0.0-canary.a9708bd",
-    "@aztec/stdlib": "3.0.0-canary.a9708bd",
-    "@aztec/telemetry-client": "3.0.0-canary.a9708bd",
+    "@aztec/epoch-cache": "3.0.0-devnet.2-patch.1",
+    "@aztec/ethereum": "3.0.0-devnet.2-patch.1",
+    "@aztec/foundation": "3.0.0-devnet.2-patch.1",
+    "@aztec/kv-store": "3.0.0-devnet.2-patch.1",
+    "@aztec/l1-artifacts": "3.0.0-devnet.2-patch.1",
+    "@aztec/stdlib": "3.0.0-devnet.2-patch.1",
+    "@aztec/telemetry-client": "3.0.0-devnet.2-patch.1",
     "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": "3.0.0-canary.a9708bd",
+    "@aztec/aztec.js": "3.0.0-devnet.2-patch.1",
     "@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';
@@ -17,8 +17,9 @@ import { EmpireSlasherClient, type EmpireSlasherSettings } from '../empire_slash
 import { NullSlasherClient } from '../null_slasher_client.js';
 import { SlasherOffensesStore } from '../stores/offenses_store.js';
 import { SlasherPayloadsStore } from '../stores/payloads_store.js';
-import { TallySlasherClient, type TallySlasherSettings } from '../tally_slasher_client.js';
+import { TallySlasherClient } from '../tally_slasher_client.js';
 import type { Watcher } from '../watcher.js';
+import { getTallySlasherSettings } from './get_settings.js';
 
 /** Creates a slasher client implementation (either tally or empire) based on the slasher proposer type in the rollup */
 export async function createSlasherImplementation(
@@ -70,6 +71,7 @@ async function createEmpireSlasher(
     l1GenesisTime,
     slotDuration,
     l1StartBlock,
+    slasher,
   ] = await Promise.all([
     slashingProposer.getExecutionDelayInRounds(),
     slashingProposer.getLifetimeInRounds(),
@@ -80,6 +82,7 @@ async function createEmpireSlasher(
     rollup.getL1GenesisTime(),
     rollup.getSlotDuration(),
     rollup.getL1StartBlock(),
+    rollup.getSlasherContract(),
   ]);
 
   const settings: EmpireSlasherSettings = {
@@ -109,6 +112,7 @@ async function createEmpireSlasher(
     settings,
     slashFactoryContract,
     slashingProposer,
+    slasher!,
     rollup,
     watchers,
     dateProvider,
@@ -132,45 +136,8 @@ async function createTallySlasher(
     throw new Error('Slashing proposer contract is not of type tally');
   }
 
-  const [
-    slashingExecutionDelayInRounds,
-    slashingRoundSize,
-    slashingRoundSizeInEpochs,
-    slashingLifetimeInRounds,
-    slashingOffsetInRounds,
-    slashingAmounts,
-    slashingQuorumSize,
-    epochDuration,
-    l1GenesisTime,
-    slotDuration,
-    targetCommitteeSize,
-  ] = await Promise.all([
-    slashingProposer.getExecutionDelayInRounds(),
-    slashingProposer.getRoundSize(),
-    slashingProposer.getRoundSizeInEpochs(),
-    slashingProposer.getLifetimeInRounds(),
-    slashingProposer.getSlashOffsetInRounds(),
-    slashingProposer.getSlashingAmounts(),
-    slashingProposer.getQuorumSize(),
-    rollup.getEpochDuration(),
-    rollup.getL1GenesisTime(),
-    rollup.getSlotDuration(),
-    rollup.getTargetCommitteeSize(),
-  ]);
-
-  const settings: TallySlasherSettings = {
-    slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
-    slashingRoundSize: Number(slashingRoundSize),
-    slashingRoundSizeInEpochs: Number(slashingRoundSizeInEpochs),
-    slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
-    slashingQuorumSize: Number(slashingQuorumSize),
-    epochDuration: Number(epochDuration),
-    l1GenesisTime: l1GenesisTime,
-    slotDuration: Number(slotDuration),
-    slashingOffsetInRounds: Number(slashingOffsetInRounds),
-    slashingAmounts,
-    targetCommitteeSize: Number(targetCommitteeSize),
-  };
+  const settings = await getTallySlasherSettings(rollup, slashingProposer);
+  const slasher = await rollup.getSlasherContract();
 
   const offensesStore = new SlasherOffensesStore(kvStore, {
     ...settings,
@@ -181,6 +148,7 @@ async function createTallySlasher(
     config,
     settings,
     slashingProposer,
+    slasher!,
     rollup,
     watchers,
     epochCache,

package/src/factory/get_settings.ts

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

package/src/factory/index.ts

@@ -1 +1,2 @@
 export { createSlasherFacade as createSlasher } from './create_facade.js';
+export { getTallySlasherSettings } from './get_settings.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,