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

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@aztec/slasher",
-  "version": "0.0.1-commit.fce3e4f",
+  "version": "0.0.1-commit.ffe5b04ea",
   "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.ffe5b04ea",
+    "@aztec/ethereum": "0.0.1-commit.ffe5b04ea",
+    "@aztec/foundation": "0.0.1-commit.ffe5b04ea",
+    "@aztec/kv-store": "0.0.1-commit.ffe5b04ea",
+    "@aztec/l1-artifacts": "0.0.1-commit.ffe5b04ea",
+    "@aztec/stdlib": "0.0.1-commit.ffe5b04ea",
+    "@aztec/telemetry-client": "0.0.1-commit.ffe5b04ea",
     "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.ffe5b04ea",
     "@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:
@@ -141,7 +155,8 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
     ...numberConfigHelper(DefaultSlasherConfig.slashMaxPayloadSize),
   },
   slashGracePeriodL2Slots: {
-    description: 'Number of L2 slots to wait before considering a slashing offense expired.',
+    description:
+      'Number of L2 slots after the network upgrade during which slashing offenses are ignored. The upgrade time is determined from the CanonicalRollupUpdated event.',
     env: 'SLASH_GRACE_PERIOD_L2_SLOTS',
     ...numberConfigHelper(DefaultSlasherConfig.slashGracePeriodL2Slots),
   },

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,13 +1,16 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import type { L1ReaderConfig, ViemClient } from '@aztec/ethereum';
-import { RollupContract } from '@aztec/ethereum/contracts';
+import { RegistryContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ReaderConfig } from '@aztec/ethereum/l1-reader';
+import type { ViemClient } from '@aztec/ethereum/types';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { unique } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
 import { SlasherClientFacade } from '../slasher_client_facade.js';
 import type { SlasherClientInterface } from '../slasher_client_interface.js';
@@ -17,7 +20,7 @@ import type { Watcher } from '../watcher.js';
 /** Creates a slasher client facade that updates itself whenever the rollup slasher changes */
 export async function createSlasherFacade(
   config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
-  l1Contracts: Pick<L1ReaderConfig['l1Contracts'], 'rollupAddress' | 'slashFactoryAddress'>,
+  l1Contracts: Pick<L1ReaderConfig['l1Contracts'], 'rollupAddress' | 'slashFactoryAddress' | 'registryAddress'>,
   l1Client: ViemClient,
   watchers: Watcher[],
   dateProvider: DateProvider,
@@ -30,9 +33,35 @@ 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);
 
+  // Compute and cache the L2 slot at which the rollup was registered as canonical
+  const settingsMap = kvStore.openMap<string, number>('slasher-settings');
+  const cacheKey = `registeredSlot:${l1Contracts.rollupAddress}`;
+  let rollupRegisteredAtL2Slot = (await settingsMap.getAsync(cacheKey)) as SlotNumber | undefined;
+
+  if (rollupRegisteredAtL2Slot === undefined) {
+    const registry = new RegistryContract(l1Client, l1Contracts.registryAddress);
+    const l1StartBlock = await rollup.getL1StartBlock();
+    const registrationTimestamp = await registry.getCanonicalRollupRegistrationTimestamp(
+      l1Contracts.rollupAddress,
+      l1StartBlock,
+    );
+    if (registrationTimestamp !== undefined) {
+      const l1GenesisTime = await rollup.getL1GenesisTime();
+      const slotDuration = await rollup.getSlotDuration();
+      rollupRegisteredAtL2Slot = getSlotAtTimestamp(registrationTimestamp, {
+        l1GenesisTime,
+        slotDuration: Number(slotDuration),
+      });
+    } else {
+      rollupRegisteredAtL2Slot = SlotNumber(0);
+    }
+    await settingsMap.set(cacheKey, rollupRegisteredAtL2Slot);
+    logger.info(`Canonical rollup registered at L2 slot ${rollupRegisteredAtL2Slot}`);
+  }
+
   const slashValidatorsNever = config.slashSelfAllowed
     ? config.slashValidatorsNever
     : unique([...config.slashValidatorsNever, ...validatorAddresses].map(a => a.toString())).map(EthAddress.fromString);
@@ -47,6 +76,7 @@ export async function createSlasherFacade(
     epochCache,
     dateProvider,
     kvStore,
+    rollupRegisteredAtL2Slot,
     logger,
   );
 }

package/src/factory/create_implementation.ts

@@ -1,16 +1,17 @@
 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 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';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { AztecLMDBStoreV2 } from '@aztec/kv-store/lmdb-v2';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 
 import { EmpireSlasherClient, type EmpireSlasherSettings } from '../empire_slasher_client.js';
@@ -31,19 +32,40 @@ export async function createSlasherImplementation(
   epochCache: EpochCache,
   dateProvider: DateProvider,
   kvStore: AztecLMDBStoreV2,
+  rollupRegisteredAtL2Slot: SlotNumber,
   logger = createLogger('slasher'),
 ) {
   const proposer = await rollup.getSlashingProposer();
   if (!proposer) {
     return new NullSlasherClient(config);
   } else if (proposer.type === 'tally') {
-    return createTallySlasher(config, rollup, proposer, watchers, dateProvider, epochCache, kvStore, logger);
+    return createTallySlasher(
+      config,
+      rollup,
+      proposer,
+      watchers,
+      dateProvider,
+      epochCache,
+      kvStore,
+      rollupRegisteredAtL2Slot,
+      logger,
+    );
   } else {
     if (!slashFactoryAddress || slashFactoryAddress.equals(EthAddress.ZERO)) {
       throw new Error('Cannot initialize an empire-based SlasherClient without a SlashFactory address');
     }
     const slashFactory = new SlashFactoryContract(l1Client, slashFactoryAddress.toString());
-    return createEmpireSlasher(config, rollup, proposer, slashFactory, watchers, dateProvider, kvStore, logger);
+    return createEmpireSlasher(
+      config,
+      rollup,
+      proposer,
+      slashFactory,
+      watchers,
+      dateProvider,
+      kvStore,
+      rollupRegisteredAtL2Slot,
+      logger,
+    );
   }
 }
 
@@ -55,6 +77,7 @@ async function createEmpireSlasher(
   watchers: Watcher[],
   dateProvider: DateProvider,
   kvStore: AztecLMDBStoreV2,
+  rollupRegisteredAtL2Slot: SlotNumber,
   logger = createLogger('slasher'),
 ): Promise<EmpireSlasherClient> {
   if (slashingProposer.type !== 'empire') {
@@ -97,6 +120,7 @@ async function createEmpireSlasher(
     l1StartBlock,
     ethereumSlotDuration: config.ethereumSlotDuration,
     slashingAmounts: undefined,
+    rollupRegisteredAtL2Slot,
   };
 
   const payloadsStore = new SlasherPayloadsStore(kvStore, {
@@ -130,13 +154,14 @@ async function createTallySlasher(
   dateProvider: DateProvider,
   epochCache: EpochCache,
   kvStore: AztecLMDBStoreV2,
+  rollupRegisteredAtL2Slot: SlotNumber,
   logger = createLogger('slasher'),
 ): Promise<TallySlasherClient> {
   if (slashingProposer.type !== 'tally') {
     throw new Error('Slashing proposer contract is not of type tally');
   }
 
-  const settings = await getTallySlasherSettings(rollup, slashingProposer);
+  const settings = { ...(await getTallySlasherSettings(rollup, slashingProposer)), rollupRegisteredAtL2Slot };
   const slasher = await rollup.getSlasherContract();
 
   const offensesStore = new SlasherOffensesStore(kvStore, {

package/src/factory/get_settings.ts

@@ -1,11 +1,11 @@
-import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
+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> {
+): Promise<Omit<TallySlasherSettings, 'rollupRegisteredAtL2Slot'>> {
   if (!slashingProposer) {
     const rollupSlashingProposer = await rollup.getSlashingProposer();
     if (!rollupSlashingProposer || rollupSlashingProposer.type !== 'tally') {
@@ -40,7 +40,7 @@ export async function getTallySlasherSettings(
     rollup.getTargetCommitteeSize(),
   ]);
 
-  const settings: TallySlasherSettings = {
+  const settings: Omit<TallySlasherSettings, 'rollupRegisteredAtL2Slot'> = {
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
     slashingRoundSize: Number(slashingRoundSize),
     slashingRoundSizeInEpochs: Number(slashingRoundSizeInEpochs),

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: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_PRUNE_PENALTY: 10000000000000000000,
+  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
+  SLASH_INACTIVITY_PENALTY: 10000000000000000000,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
+  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
+} as const;

package/src/slash_offenses_collector.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { Prettify } from '@aztec/foundation/types';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
@@ -9,7 +10,11 @@ import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher } from './watch
 
 export type SlashOffensesCollectorConfig = Prettify<Pick<SlasherConfig, 'slashGracePeriodL2Slots'>>;
 export type SlashOffensesCollectorSettings = Prettify<
-  Pick<L1RollupConstants, 'epochDuration'> & { slashingAmounts: [bigint, bigint, bigint] | undefined }
+  Pick<L1RollupConstants, 'epochDuration'> & {
+    slashingAmounts: [bigint, bigint, bigint] | undefined;
+    /** L2 slot at which the rollup was registered as canonical in the Registry. Used to anchor the slash grace period. */
+    rollupRegisteredAtL2Slot: SlotNumber;
+  }
 >;
 
 /**
@@ -110,9 +115,9 @@ export class SlashOffensesCollector {
     return this.offensesStore.markAsSlashed(offenses);
   }
 
-  /** Returns whether to skip an offense if it happened during the grace period at the beginning of the chain */
+  /** Returns whether to skip an offense if it happened during the grace period after the network upgrade */
   private shouldSkipOffense(offense: Offense): boolean {
     const offenseSlot = getSlotForOffense(offense, this.settings);
-    return offenseSlot < this.config.slashGracePeriodL2Slots;
+    return offenseSlot < this.settings.rollupRegisteredAtL2Slot + this.config.slashGracePeriodL2Slots;
   }
 }

package/src/slasher_client_facade.ts

@@ -1,13 +1,13 @@
 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';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { AztecLMDBStoreV2 } from '@aztec/kv-store/lmdb-v2';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
 
 import { createSlasherImplementation } from './factory/create_implementation.js';
@@ -32,6 +32,7 @@ export class SlasherClientFacade implements SlasherClientInterface {
     private epochCache: EpochCache,
     private dateProvider: DateProvider,
     private kvStore: AztecLMDBStoreV2,
+    private rollupRegisteredAtL2Slot: SlotNumber,
     private logger = createLogger('slasher'),
   ) {}
 
@@ -88,6 +89,7 @@ export class SlasherClientFacade implements SlasherClientInterface {
       this.epochCache,
       this.dateProvider,
       this.kvStore,
+      this.rollupRegisteredAtL2Slot,
       this.logger,
     );
   }

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> {

package/src/tally_slasher_client.ts

@@ -5,7 +5,6 @@ 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';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { Prettify } from '@aztec/foundation/types';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
@@ -47,7 +46,10 @@ export type TallySlasherSettings = Prettify<
 >;
 
 export type TallySlasherClientConfig = SlashOffensesCollectorConfig &
-  Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack'>;
+  Pick<
+    SlasherConfig,
+    'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack' | 'slashMaxPayloadSize'
+  >;
 
 /**
  * The Tally Slasher client is responsible for managing slashable offenses using
@@ -138,8 +140,6 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     this.roundMonitor.stop();
     await this.offensesCollector.stop();
 
-    // Sleeping to sidestep viem issue with unwatching events
-    await sleep(2000);
     this.log.info('Tally Slasher client stopped');
   }
 
@@ -281,8 +281,12 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
         return undefined;
       }
 
+      const slashActionsWithAmounts = slashActions.map(action => ({
+        validator: action.validator.toString(),
+        slashAmount: action.slashAmount.toString(),
+      }));
       this.log.info(`Round ${executableRound} is ready to execute with ${slashActions.length} slashes`, {
-        slashActions,
+        slashActions: slashActionsWithAmounts,
         payloadAddress: payload.address.toString(),
         ...logData,
       });
@@ -357,11 +361,13 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
     const committees = await this.collectCommitteesActiveDuringRound(slashedRound);
     const epochsForCommittees = getEpochsForRound(slashedRound, this.settings);
+    const { slashMaxPayloadSize } = this.config;
     const votes = getSlashConsensusVotesFromOffenses(
       offensesToSlash,
       committees,
       epochsForCommittees.map(e => BigInt(e)),
-      this.settings,
+      { ...this.settings, maxSlashedValidators: slashMaxPayloadSize },
+      this.log,
     );
     if (votes.every(v => v === 0)) {
       this.log.warn(`Computed votes for offenses are all zero. Skipping vote.`, {

package/src/watcher.ts

@@ -10,7 +10,7 @@ export interface WantToSlashArgs {
   validator: EthAddress;
   amount: bigint;
   offenseType: OffenseType;
-  epochOrSlot: bigint; // Epoch number for epoch-based offenses, block number for block-based
+  epochOrSlot: bigint; // Epoch number for epoch-based offenses, slot number for slot-based
 }
 
 // Event map for specific, known events of a watcher