@aztec/slasher 0.0.1-commit.d431d1c → 0.0.1-commit.d939eb5aa

package/src/factory/create_implementation.ts

@@ -1,142 +1,61 @@
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  EmpireSlashingProposerContract,
-  RollupContract,
-  TallySlashingProposerContract,
-} from '@aztec/ethereum/contracts';
+import { RollupContract, SlashingProposerContract } from '@aztec/ethereum/contracts';
 import type { ViemClient } from '@aztec/ethereum/types';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 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 { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
-import { EmpireSlasherClient, type EmpireSlasherSettings } from '../empire_slasher_client.js';
 import { NullSlasherClient } from '../null_slasher_client.js';
+import { SlasherClient } from '../slasher_client.js';
 import { SlasherOffensesStore } from '../stores/offenses_store.js';
-import { SlasherPayloadsStore } from '../stores/payloads_store.js';
-import { TallySlasherClient } from '../tally_slasher_client.js';
 import type { Watcher } from '../watcher.js';
-import { getTallySlasherSettings } from './get_settings.js';
+import { getSlasherSettings } from './get_settings.js';
 
-/** Creates a slasher client implementation (either tally or empire) based on the slasher proposer type in the rollup */
+/** Creates a slasher client implementation based on the slasher proposer type in the rollup */
 export async function createSlasherImplementation(
   config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
   rollup: RollupContract,
   l1Client: ViemClient,
-  slashFactoryAddress: EthAddress | undefined,
   watchers: Watcher[],
   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);
   } 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 createSlasher(
+      config,
+      rollup,
+      proposer,
+      watchers,
+      dateProvider,
+      epochCache,
+      kvStore,
+      rollupRegisteredAtL2Slot,
+      logger,
+    );
   }
 }
 
-async function createEmpireSlasher(
-  config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
-  rollup: RollupContract,
-  slashingProposer: EmpireSlashingProposerContract,
-  slashFactoryContract: SlashFactoryContract,
-  watchers: Watcher[],
-  dateProvider: DateProvider,
-  kvStore: AztecLMDBStoreV2,
-  logger = createLogger('slasher'),
-): Promise<EmpireSlasherClient> {
-  if (slashingProposer.type !== 'empire') {
-    throw new Error('Slashing proposer contract is not of type Empire');
-  }
-
-  const [
-    slashingExecutionDelayInRounds,
-    slashingPayloadLifetimeInRounds,
-    slashingRoundSize,
-    slashingQuorumSize,
-    epochDuration,
-    proofSubmissionEpochs,
-    l1GenesisTime,
-    slotDuration,
-    l1StartBlock,
-    slasher,
-  ] = await Promise.all([
-    slashingProposer.getExecutionDelayInRounds(),
-    slashingProposer.getLifetimeInRounds(),
-    slashingProposer.getRoundSize(),
-    slashingProposer.getQuorumSize(),
-    rollup.getEpochDuration(),
-    rollup.getProofSubmissionEpochs(),
-    rollup.getL1GenesisTime(),
-    rollup.getSlotDuration(),
-    rollup.getL1StartBlock(),
-    rollup.getSlasherContract(),
-  ]);
-
-  const settings: EmpireSlasherSettings = {
-    slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
-    slashingPayloadLifetimeInRounds: Number(slashingPayloadLifetimeInRounds),
-    slashingRoundSize: Number(slashingRoundSize),
-    slashingQuorumSize: Number(slashingQuorumSize),
-    epochDuration: Number(epochDuration),
-    proofSubmissionEpochs: Number(proofSubmissionEpochs),
-    l1GenesisTime: l1GenesisTime,
-    slotDuration: Number(slotDuration),
-    l1StartBlock,
-    ethereumSlotDuration: config.ethereumSlotDuration,
-    slashingAmounts: undefined,
-  };
-
-  const payloadsStore = new SlasherPayloadsStore(kvStore, {
-    slashingPayloadLifetimeInRounds: settings.slashingPayloadLifetimeInRounds,
-  });
-  const offensesStore = new SlasherOffensesStore(kvStore, {
-    ...settings,
-    slashOffenseExpirationRounds: config.slashOffenseExpirationRounds,
-  });
-
-  return new EmpireSlasherClient(
-    config,
-    settings,
-    slashFactoryContract,
-    slashingProposer,
-    slasher!,
-    rollup,
-    watchers,
-    dateProvider,
-    offensesStore,
-    payloadsStore,
-    logger,
-  );
-}
-
-async function createTallySlasher(
+async function createSlasher(
   config: SlasherConfig & DataStoreConfig,
   rollup: RollupContract,
-  slashingProposer: TallySlashingProposerContract,
+  slashingProposer: SlashingProposerContract,
   watchers: Watcher[],
   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);
+): Promise<SlasherClient> {
+  const settings = { ...(await getSlasherSettings(rollup, slashingProposer)), rollupRegisteredAtL2Slot };
   const slasher = await rollup.getSlasherContract();
 
   const offensesStore = new SlasherOffensesStore(kvStore, {
@@ -144,7 +63,7 @@ async function createTallySlasher(
     slashOffenseExpirationRounds: config.slashOffenseExpirationRounds,
   });
 
-  return new TallySlasherClient(
+  return new SlasherClient(
     config,
     settings,
     slashingProposer,

package/src/factory/get_settings.ts

@@ -1,15 +1,15 @@
-import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import type { RollupContract, SlashingProposerContract } from '@aztec/ethereum/contracts';
 
-import type { TallySlasherSettings } from '../tally_slasher_client.js';
+import type { SlasherSettings } from '../slasher_client.js';
 
-export async function getTallySlasherSettings(
+export async function getSlasherSettings(
   rollup: RollupContract,
-  slashingProposer?: TallySlashingProposerContract,
-): Promise<TallySlasherSettings> {
+  slashingProposer?: SlashingProposerContract,
+): Promise<Omit<SlasherSettings, 'rollupRegisteredAtL2Slot'>> {
   if (!slashingProposer) {
     const rollupSlashingProposer = await rollup.getSlashingProposer();
-    if (!rollupSlashingProposer || rollupSlashingProposer.type !== 'tally') {
-      throw new Error('Rollup slashing proposer is not of type tally');
+    if (!rollupSlashingProposer) {
+      throw new Error('Rollup slashing proposer not found');
     }
     slashingProposer = rollupSlashingProposer;
   }
@@ -40,7 +40,7 @@ export async function getTallySlasherSettings(
     rollup.getTargetCommitteeSize(),
   ]);
 
-  const settings: TallySlasherSettings = {
+  const settings: Omit<SlasherSettings, 'rollupRegisteredAtL2Slot'> = {
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
     slashingRoundSize: Number(slashingRoundSize),
     slashingRoundSizeInEpochs: Number(slashingRoundSizeInEpochs),

package/src/factory/index.ts

@@ -1,2 +1,2 @@
 export { createSlasherFacade as createSlasher } from './create_facade.js';
-export { getTallySlasherSettings } from './get_settings.js';
+export { getSlasherSettings } from './get_settings.js';

package/src/generated/slasher-defaults.ts

@@ -3,10 +3,8 @@
 
 /** 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_MAX_PAYLOAD_SIZE: 80,
   SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
   SLASH_PRUNE_PENALTY: 10000000000000000000,
   SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
@@ -15,6 +13,8 @@ export const slasherDefaultEnv = {
   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,

package/src/index.ts

@@ -1,8 +1,7 @@
 export * from './config.js';
 export * from './watchers/epoch_prune_watcher.js';
 export * from './watchers/attestations_block_watcher.js';
-export * from './empire_slasher_client.js';
-export * from './tally_slasher_client.js';
+export * from './slasher_client.js';
 export * from './slash_offenses_collector.js';
 export * from './slasher_client_interface.js';
 export * from './factory/index.js';

package/src/null_slasher_client.ts

@@ -1,5 +1,5 @@
 import type { SlotNumber } from '@aztec/foundation/branded-types';
-import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
+import type { Offense, ProposerSlashAction } from '@aztec/stdlib/slashing';
 
 import type { SlasherConfig } from './config.js';
 import type { SlasherClientInterface } from './slasher_client_interface.js';
@@ -15,15 +15,11 @@ export class NullSlasherClient implements SlasherClientInterface {
     return Promise.resolve();
   }
 
-  public getSlashPayloads(): Promise<SlashPayloadRound[]> {
-    return Promise.resolve([]);
-  }
-
   public gatherOffensesForRound(_round?: bigint): Promise<Offense[]> {
     return Promise.resolve([]);
   }
 
-  public getPendingOffenses(): Promise<Offense[]> {
+  public getOffenses(): Promise<Offense[]> {
     return Promise.resolve([]);
   }
 

package/src/slash_offenses_collector.ts

@@ -1,15 +1,20 @@
+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';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
-import { type Offense, type OffenseIdentifier, getSlotForOffense } from '@aztec/stdlib/slashing';
+import { type Offense, getSlotForOffense } from '@aztec/stdlib/slashing';
 
 import type { SlasherOffensesStore } from './stores/offenses_store.js';
 import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher } from './watcher.js';
 
 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;
+  }
 >;
 
 /**
@@ -61,20 +66,20 @@ export class SlashOffensesCollector {
    */
   public async handleWantToSlash(args: WantToSlashArgs[]) {
     for (const arg of args) {
-      const pendingOffense: Offense = {
+      const offense: Offense = {
         validator: arg.validator,
         amount: arg.amount,
         offenseType: arg.offenseType,
         epochOrSlot: arg.epochOrSlot,
       };
 
-      if (this.shouldSkipOffense(pendingOffense)) {
-        this.log.verbose('Skipping offense during grace period', pendingOffense);
+      if (this.shouldSkipOffense(offense)) {
+        this.log.verbose('Skipping offense during grace period', offense);
         continue;
       }
 
-      if (await this.offensesStore.hasOffense(pendingOffense)) {
-        this.log.debug('Skipping repeated offense', pendingOffense);
+      if (await this.offensesStore.hasOffense(offense)) {
+        this.log.debug('Skipping repeated offense', offense);
         continue;
       }
 
@@ -85,8 +90,8 @@ export class SlashOffensesCollector {
         }
       }
 
-      this.log.info(`Adding pending offense for validator ${arg.validator}`, pendingOffense);
-      await this.offensesStore.addPendingOffense(pendingOffense);
+      this.log.info(`Adding pending offense for validator ${arg.validator}`, offense);
+      await this.offensesStore.addOffense(offense);
     }
   }
 
@@ -101,18 +106,9 @@ export class SlashOffensesCollector {
     }
   }
 
-  /**
-   * Marks offenses as slashed (no longer pending)
-   * @param offenses - The offenses to mark as slashed
-   */
-  public markAsSlashed(offenses: OffenseIdentifier[]) {
-    this.log.verbose(`Marking offenses as slashed`, { offenses });
-    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/{tally_slasher_client.ts → slasher_client.ts}

@@ -1,11 +1,10 @@
 import { EthAddress } from '@aztec/aztec.js/addresses';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { RollupContract, SlasherContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import { RollupContract, SlasherContract, SlashingProposerContract } 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';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { Prettify } from '@aztec/foundation/types';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
@@ -14,7 +13,6 @@ import {
   OffenseType,
   type ProposerSlashAction,
   type ProposerSlashActionProvider,
-  type SlashPayloadRound,
   getEpochsForRound,
   getSlashConsensusVotesFromOffenses,
 } from '@aztec/stdlib/slashing';
@@ -31,8 +29,8 @@ import type { SlasherClientInterface } from './slasher_client_interface.js';
 import type { SlasherOffensesStore } from './stores/offenses_store.js';
 import type { Watcher } from './watcher.js';
 
-/** Settings used in the tally slasher client, loaded from the L1 contracts during initialization */
-export type TallySlasherSettings = Prettify<
+/** Settings used in the slasher client, loaded from the L1 contracts during initialization */
+export type SlasherSettings = Prettify<
   SlashRoundMonitorSettings &
     SlashOffensesCollectorSettings & {
       slashingLifetimeInRounds: number;
@@ -46,11 +44,14 @@ export type TallySlasherSettings = Prettify<
     }
 >;
 
-export type TallySlasherClientConfig = SlashOffensesCollectorConfig &
-  Pick<SlasherConfig, 'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack'>;
+export type SlasherClientConfig = SlashOffensesCollectorConfig &
+  Pick<
+    SlasherConfig,
+    'slashValidatorsAlways' | 'slashValidatorsNever' | 'slashExecuteRoundsLookBack' | 'slashMaxPayloadSize'
+  >;
 
 /**
- * The Tally Slasher client is responsible for managing slashable offenses using
+ * The Slasher client is responsible for managing slashable offenses using
  * the consensus-based slashing model where proposers vote on individual validator offenses.
  *
  * The client subscribes to several slash watchers that emit offenses and tracks them. When the slasher is the
@@ -74,22 +75,16 @@ export type TallySlasherClientConfig = SlashOffensesCollectorConfig &
  * - Validators that reach the quorum threshold are slashed. A vote for slashing N units is also considered
  * a vote for slashing N-1, N-2, ..., 1 units. The system slashes for the largest amount that reaches quorum.
  * - The client monitors executable rounds and triggers execution when appropriate.
- *
- * Differences from Empire model
- * - No fixed slash payloads - votes are for individual validator offenses encoded in bytes
- * - The L1 contract determines which offenses reach quorum rather than nodes agreeing on a payload
- * - Proposers vote directly on which validators to slash and by how much
- * - Uses a slash offset to vote on validators from past rounds (e.g., round N votes on round N-2)
  */
-export class TallySlasherClient implements ProposerSlashActionProvider, SlasherClientInterface {
+export class SlasherClient implements ProposerSlashActionProvider, SlasherClientInterface {
   protected unwatchCallbacks: (() => void)[] = [];
   protected roundMonitor: SlashRoundMonitor;
   protected offensesCollector: SlashOffensesCollector;
 
   constructor(
-    private config: TallySlasherClientConfig,
-    private settings: TallySlasherSettings,
-    private tallySlashingProposer: TallySlashingProposerContract,
+    private config: SlasherClientConfig,
+    private settings: SlasherSettings,
+    private slashingProposer: SlashingProposerContract,
     private slasher: SlasherContract,
     private rollup: RollupContract,
     watchers: Watcher[],
@@ -103,14 +98,14 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
   }
 
   public async start() {
-    this.log.debug('Starting Tally Slasher client...');
+    this.log.debug('Starting slasher client...');
 
     this.roundMonitor.start();
     await this.offensesCollector.start();
 
     // Listen for RoundExecuted events
     this.unwatchCallbacks.push(
-      this.tallySlashingProposer.listenToRoundExecuted(
+      this.slashingProposer.listenToRoundExecuted(
         ({ round, slashCount, l1BlockHash }) =>
           void this.handleRoundExecuted(round, slashCount, l1BlockHash).catch(err =>
             this.log.error('Error handling round executed', err),
@@ -121,15 +116,13 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     // Check for round changes
     this.unwatchCallbacks.push(this.roundMonitor.listenToNewRound(round => this.handleNewRound(round)));
 
-    this.log.info(`Started tally slasher client`);
+    this.log.info(`Started slasher client`);
     return Promise.resolve();
   }
 
-  /**
-   * Stop the tally slasher client
-   */
+  /** Stop the slasher client */
   public async stop() {
-    this.log.debug('Stopping Tally Slasher client...');
+    this.log.debug('Stopping slasher client...');
 
     for (const unwatchCallback of this.unwatchCallbacks) {
       unwatchCallback();
@@ -138,9 +131,7 @@ 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');
+    this.log.info('Slasher client stopped');
   }
 
   /** Returns the current config */
@@ -155,11 +146,11 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
 
   /** Triggered on a time basis when we enter a new slashing round. Clears expired offenses. */
   protected async handleNewRound(round: bigint) {
-    this.log.info(`Starting new tally slashing round ${round}`);
+    this.log.info(`Starting new slashing round ${round}`);
     await this.offensesCollector.handleNewRound(round);
   }
 
-  /** Called when we see a RoundExecuted event on the TallySlashingProposer (just for logging). */
+  /** Called when we see a RoundExecuted event on the SlashingProposer (just for logging). */
   protected async handleRoundExecuted(round: bigint, slashCount: bigint, l1BlockHash: Hex) {
     const slashes = await this.rollup.getSlashEvents(l1BlockHash);
     this.log.info(`Slashing round ${round} has been executed with ${slashCount} slashes`, { slashes });
@@ -240,7 +231,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
 
     try {
-      const roundInfo = await this.tallySlashingProposer.getRound(executableRound);
+      const roundInfo = await this.slashingProposer.getRound(executableRound);
       logData = { ...logData, roundInfo };
       if (roundInfo.isExecuted) {
         this.log.verbose(`Round ${executableRound} has already been executed`, logData);
@@ -254,7 +245,7 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       }
 
       // Check if round is ready to execute at the given slot
-      const isReadyToExecute = await this.tallySlashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
+      const isReadyToExecute = await this.slashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
       if (!isReadyToExecute) {
         this.log.warn(
           `Round ${executableRound} is not ready to execute at slot ${slotNumber} according to contract check`,
@@ -264,14 +255,14 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       }
 
       // Check if the round yields any slashing at all
-      const { actions: slashActions, committees } = await this.tallySlashingProposer.getTally(executableRound);
+      const { actions: slashActions, committees } = await this.slashingProposer.getTally(executableRound);
       if (slashActions.length === 0) {
         this.log.verbose(`Round ${executableRound} does not resolve in any slashing`, logData);
         return undefined;
       }
 
       // Check if the slash payload is vetoed
-      const payload = await this.tallySlashingProposer.getPayload(executableRound);
+      const payload = await this.slashingProposer.getPayload(executableRound);
       const isVetoed = await this.slasher.isPayloadVetoed(payload.address);
       if (isVetoed) {
         this.log.warn(`Round ${executableRound} payload is vetoed (skipping execution)`, {
@@ -281,8 +272,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 +352,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.`, {
@@ -399,17 +396,9 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     );
   }
 
-  /**
-   * Get slash payloads is NOT SUPPORTED in tally model
-   * @throws Error indicating this operation is not supported
-   */
-  public getSlashPayloads(): Promise<SlashPayloadRound[]> {
-    return Promise.reject(new Error('Tally slashing model does not support slash payloads'));
-  }
-
   /**
    * Gather offenses to be slashed on a given round.
-   * In tally slashing, round N slashes validators from round N - slashOffsetInRounds.
+   * Round N slashes validators from round N - slashOffsetInRounds.
    * @param round - The round to get offenses for, defaults to current round
    * @returns Array of pending offenses for the round with offset applied
    */
@@ -422,9 +411,9 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     return await this.offensesStore.getOffensesForRound(targetRound);
   }
 
-  /** Returns all pending offenses stored */
-  public getPendingOffenses(): Promise<Offense[]> {
-    return this.offensesStore.getPendingOffenses();
+  /** Returns all offenses stored */
+  public getOffenses(): Promise<Offense[]> {
+    return this.offensesStore.getOffenses();
   }
 
   /**

package/src/slasher_client_facade.ts

@@ -2,13 +2,12 @@ import { EpochCache } from '@aztec/epoch-cache';
 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 { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
+import type { Offense, ProposerSlashAction } from '@aztec/stdlib/slashing';
 
 import { createSlasherImplementation } from './factory/create_implementation.js';
 import type { SlasherClientInterface } from './slasher_client_interface.js';
@@ -27,11 +26,11 @@ export class SlasherClientFacade implements SlasherClientInterface {
     private config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
     private rollup: RollupContract,
     private l1Client: ViemClient,
-    private slashFactoryAddress: EthAddress | undefined,
     private watchers: Watcher[],
     private epochCache: EpochCache,
     private dateProvider: DateProvider,
     private kvStore: AztecLMDBStoreV2,
+    private rollupRegisteredAtL2Slot: SlotNumber,
     private logger = createLogger('slasher'),
   ) {}
 
@@ -62,16 +61,12 @@ export class SlasherClientFacade implements SlasherClientInterface {
     this.watchers.forEach(watcher => watcher.updateConfig?.(config));
   }
 
-  public getSlashPayloads(): Promise<SlashPayloadRound[]> {
-    return this.client?.getSlashPayloads() ?? Promise.reject(new Error('Slasher client not initialized'));
-  }
-
   public gatherOffensesForRound(round?: bigint): Promise<Offense[]> {
     return this.client?.gatherOffensesForRound(round) ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 
-  public getPendingOffenses(): Promise<Offense[]> {
-    return this.client?.getPendingOffenses() ?? Promise.reject(new Error('Slasher client not initialized'));
+  public getOffenses(): Promise<Offense[]> {
+    return this.client?.getOffenses() ?? Promise.reject(new Error('Slasher client not initialized'));
   }
 
   public getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
@@ -83,11 +78,11 @@ export class SlasherClientFacade implements SlasherClientInterface {
       this.config,
       this.rollup,
       this.l1Client,
-      this.slashFactoryAddress,
       this.watchers,
       this.epochCache,
       this.dateProvider,
       this.kvStore,
+      this.rollupRegisteredAtL2Slot,
       this.logger,
     );
   }