@aztec/slasher 0.0.1-commit.21caa21

package/src/factory/create_facade.ts

@@ -0,0 +1,52 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import type { L1ReaderConfig, ViemClient } from '@aztec/ethereum';
+import { RollupContract } from '@aztec/ethereum/contracts';
+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 type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+
+import { SlasherClientFacade } from '../slasher_client_facade.js';
+import type { SlasherClientInterface } from '../slasher_client_interface.js';
+import { SCHEMA_VERSION } from '../stores/schema_version.js';
+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'>,
+  l1Client: ViemClient,
+  watchers: Watcher[],
+  dateProvider: DateProvider,
+  epochCache: EpochCache,
+  /** List of own validator addresses to add to the slashValidatorNever list unless slashSelfAllowed is true */
+  validatorAddresses: EthAddress[] = [],
+  logger = createLogger('slasher'),
+): Promise<SlasherClientInterface> {
+  if (!l1Contracts.rollupAddress || l1Contracts.rollupAddress.equals(EthAddress.ZERO)) {
+    throw new Error('Cannot initialize SlasherClient without a Rollup address');
+  }
+
+  const kvStore = await createStore('slasher', SCHEMA_VERSION, config, createLogger('slasher:lmdb'));
+  const rollup = new RollupContract(l1Client, l1Contracts.rollupAddress);
+
+  const slashValidatorsNever = config.slashSelfAllowed
+    ? config.slashValidatorsNever
+    : unique([...config.slashValidatorsNever, ...validatorAddresses].map(a => a.toString())).map(EthAddress.fromString);
+  const updatedConfig = { ...config, slashValidatorsNever };
+
+  return new SlasherClientFacade(
+    updatedConfig,
+    rollup,
+    l1Client,
+    l1Contracts.slashFactoryAddress,
+    watchers,
+    epochCache,
+    dateProvider,
+    kvStore,
+    logger,
+  );
+}

package/src/factory/create_implementation.ts

@@ -0,0 +1,159 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import type { ViemClient } from '@aztec/ethereum';
+import {
+  EmpireSlashingProposerContract,
+  RollupContract,
+  TallySlashingProposerContract,
+} from '@aztec/ethereum/contracts';
+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 { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+
+import { EmpireSlasherClient, type EmpireSlasherSettings } from '../empire_slasher_client.js';
+import { NullSlasherClient } from '../null_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';
+
+/** Creates a slasher client implementation (either tally or empire) 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,
+  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);
+  }
+}
+
+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(
+  config: SlasherConfig & DataStoreConfig,
+  rollup: RollupContract,
+  slashingProposer: TallySlashingProposerContract,
+  watchers: Watcher[],
+  dateProvider: DateProvider,
+  epochCache: EpochCache,
+  kvStore: AztecLMDBStoreV2,
+  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 slasher = await rollup.getSlasherContract();
+
+  const offensesStore = new SlasherOffensesStore(kvStore, {
+    ...settings,
+    slashOffenseExpirationRounds: config.slashOffenseExpirationRounds,
+  });
+
+  return new TallySlasherClient(
+    config,
+    settings,
+    slashingProposer,
+    slasher!,
+    rollup,
+    watchers,
+    epochCache,
+    dateProvider,
+    offensesStore,
+    logger,
+  );
+}

package/src/factory/get_settings.ts

@@ -0,0 +1,58 @@
+import type { RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
+
+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

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

package/src/index.ts

@@ -0,0 +1,10 @@
+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 './slash_offenses_collector.js';
+export * from './slasher_client_interface.js';
+export * from './factory/index.js';
+export * from './watcher.js';
+export * from '@aztec/stdlib/slashing';

package/src/null_slasher_client.ts

@@ -0,0 +1,41 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { Offense, ProposerSlashAction, SlashPayloadRound } from '@aztec/stdlib/slashing';
+
+import type { SlasherConfig } from './config.js';
+import type { SlasherClientInterface } from './slasher_client_interface.js';
+
+export class NullSlasherClient implements SlasherClientInterface {
+  constructor(private config: SlasherConfig) {}
+
+  public start(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public stop(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public getSlashPayloads(): Promise<SlashPayloadRound[]> {
+    return Promise.resolve([]);
+  }
+
+  public gatherOffensesForRound(_round?: bigint): Promise<Offense[]> {
+    return Promise.resolve([]);
+  }
+
+  public getPendingOffenses(): Promise<Offense[]> {
+    return Promise.resolve([]);
+  }
+
+  public updateConfig(config: Partial<SlasherConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  public getProposerActions(_slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
+    return Promise.resolve([]);
+  }
+
+  public getConfig(): SlasherConfig {
+    return this.config;
+  }
+}

package/src/slash_offenses_collector.ts

@@ -0,0 +1,118 @@
+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 { 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 }
+>;
+
+/**
+ * Collects and manages slashable offenses from watchers.
+ * This class handles the common logic for subscribing to slash watcher events,
+ * storing offenses, and retrieving pending offenses for slashing.
+ */
+export class SlashOffensesCollector {
+  private readonly unwatchCallbacks: (() => void)[] = [];
+
+  constructor(
+    private readonly config: SlashOffensesCollectorConfig,
+    private readonly settings: SlashOffensesCollectorSettings,
+    private readonly watchers: Watcher[],
+    private readonly offensesStore: SlasherOffensesStore,
+    private readonly log = createLogger('slasher:offenses-collector'),
+  ) {}
+
+  public start() {
+    this.log.debug('Starting SlashOffensesCollector...');
+
+    // Subscribe to watchers WANT_TO_SLASH_EVENT
+    for (const watcher of this.watchers) {
+      const wantToSlashCallback = (args: WantToSlashArgs[]) =>
+        void this.handleWantToSlash(args).catch(err => this.log.error('Error handling wantToSlash', err));
+      watcher.on(WANT_TO_SLASH_EVENT, wantToSlashCallback);
+      this.unwatchCallbacks.push(() => watcher.removeListener(WANT_TO_SLASH_EVENT, wantToSlashCallback));
+    }
+
+    this.log.info('Started SlashOffensesCollector');
+    return Promise.resolve();
+  }
+
+  public stop() {
+    this.log.debug('Stopping SlashOffensesCollector...');
+
+    for (const unwatchCallback of this.unwatchCallbacks) {
+      unwatchCallback();
+    }
+
+    this.log.info('SlashOffensesCollector stopped');
+    return Promise.resolve();
+  }
+
+  /**
+   * Called when a slash watcher emits WANT_TO_SLASH_EVENT.
+   * Stores pending offenses instead of creating payloads immediately.
+   * @param args - the arguments from the watcher, including the validators, amounts, and offenses
+   */
+  public async handleWantToSlash(args: WantToSlashArgs[]) {
+    for (const arg of args) {
+      const pendingOffense: 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);
+        continue;
+      }
+
+      if (await this.offensesStore.hasOffense(pendingOffense)) {
+        this.log.debug('Skipping repeated offense', pendingOffense);
+        continue;
+      }
+
+      if (this.settings.slashingAmounts) {
+        const minSlash = this.settings.slashingAmounts[0];
+        if (arg.amount < minSlash) {
+          this.log.warn(`Offense amount ${arg.amount} is below minimum slashing amount ${minSlash}`);
+        }
+      }
+
+      this.log.info(`Adding pending offense for validator ${arg.validator}`, pendingOffense);
+      await this.offensesStore.addPendingOffense(pendingOffense);
+    }
+  }
+
+  /**
+   * Triggered on a time basis when we enter a new slashing round.
+   * Clears expired offenses from stores.
+   */
+  public async handleNewRound(round: bigint) {
+    const cleared = await this.offensesStore.clearExpiredOffenses(round);
+    if (cleared && cleared > 0) {
+      this.log.debug(`Cleared ${cleared} expired offenses for round ${round}`);
+    }
+  }
+
+  /**
+   * 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 */
+  private shouldSkipOffense(offense: Offense): boolean {
+    const offenseSlot = getSlotForOffense(offense, this.settings);
+    return offenseSlot < this.config.slashGracePeriodL2Slots;
+  }
+}

package/src/slash_round_monitor.ts

@@ -0,0 +1,62 @@
+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';
+import { type L1RollupConstants, getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
+import { getRoundForSlot } from '@aztec/stdlib/slashing';
+
+export type SlashRoundMonitorSettings = Prettify<
+  Pick<L1RollupConstants, 'epochDuration' | 'l1GenesisTime' | 'slotDuration'> & { slashingRoundSize: number }
+>;
+
+export class SlashRoundMonitor {
+  private currentRound: bigint = 0n;
+  private intervalId: NodeJS.Timeout | undefined = undefined;
+  private handler: ((round: bigint) => Promise<void>) | undefined = undefined;
+
+  constructor(
+    private settings: SlashRoundMonitorSettings,
+    private dateProvider: DateProvider,
+    private log = createLogger('slasher:round-monitor'),
+  ) {}
+
+  public start() {
+    // Check for round changes
+    this.currentRound = this.getCurrentRound().round;
+    this.intervalId = setInterval(() => {
+      const round = this.getCurrentRound().round;
+      if (round !== this.currentRound) {
+        this.currentRound = round;
+        if (this.handler) {
+          void this.handler(round).catch(err => this.log.error('Error handling new round', err));
+        }
+      }
+    }, 500);
+  }
+
+  public stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = undefined;
+    }
+  }
+
+  public listenToNewRound(handler: (round: bigint) => Promise<void>): () => void {
+    this.handler = handler;
+    return () => {
+      this.handler = undefined;
+    };
+  }
+
+  /** Returns the slashing round number and the voting slot within the round based on the L2 chain slot */
+  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: SlotNumber } {
+    const now = this.dateProvider.nowInSeconds();
+    const currentSlot = getSlotAtTimestamp(BigInt(now), this.settings);
+    return this.getRoundForSlot(currentSlot);
+  }
+}

package/src/slasher_client_facade.ts

@@ -0,0 +1,101 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import type { ViemClient } from '@aztec/ethereum';
+import { RollupContract } from '@aztec/ethereum/contracts';
+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 { createSlasherImplementation } from './factory/create_implementation.js';
+import type { SlasherClientInterface } from './slasher_client_interface.js';
+import type { Watcher } from './watcher.js';
+
+/**
+ * Facade for the Slasher client. This class forwards all requests to the actual Slasher client implementation.
+ * This class also monitors via the rollup contract when the underlying slasher proposer contract changes, and when it
+ * does, it stops the current slasher client, recreates a new one with the new contract address, and starts it again.
+ */
+export class SlasherClientFacade implements SlasherClientInterface {
+  private client: SlasherClientInterface | undefined;
+  private unwatch: (() => void) | undefined;
+
+  constructor(
+    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 logger = createLogger('slasher'),
+  ) {}
+
+  public async start(): Promise<void> {
+    this.client = await this.createSlasherClient();
+    await this.client?.start();
+
+    this.unwatch = this.rollup.listenToSlasherChanged(() => {
+      void this.handleSlasherChange().catch(error => {
+        this.logger.error('Error handling slasher change', error);
+      });
+    });
+  }
+
+  public async stop(): Promise<void> {
+    await this.client?.stop();
+    this.unwatch?.();
+    this.unwatch = undefined;
+  }
+
+  public getConfig(): SlasherConfig {
+    return this.config;
+  }
+
+  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[]> {
+    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 getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]> {
+    return this.client?.getProposerActions(slotNumber) ?? Promise.reject(new Error('Slasher client not initialized'));
+  }
+
+  private createSlasherClient() {
+    return createSlasherImplementation(
+      this.config,
+      this.rollup,
+      this.l1Client,
+      this.slashFactoryAddress,
+      this.watchers,
+      this.epochCache,
+      this.dateProvider,
+      this.kvStore,
+      this.logger,
+    );
+  }
+
+  private async handleSlasherChange() {
+    this.logger.warn('Slasher contract changed, recreating slasher client');
+    await this.client?.stop();
+    this.client = await this.createSlasherClient();
+    await this.client?.start();
+  }
+}

package/src/slasher_client_interface.ts

@@ -0,0 +1,46 @@
+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';
+
+/**
+ * Common interface for slasher clients used by the Aztec node.
+ * Both Empire and Consensus slasher clients implement this interface.
+ */
+export interface SlasherClientInterface {
+  /** Start the slasher client */
+  start(): Promise<void>;
+
+  /** Stop the slasher client */
+  stop(): Promise<void>;
+
+  /**
+   * Get slash payloads for the Empire model.
+   * The Consensus model should throw an error when this is called.
+   */
+  getSlashPayloads(): Promise<SlashPayloadRound[]>;
+
+  /**
+   * Gather offenses for a given round, defaults to current.
+   * Used by both Empire and Consensus models.
+   */
+  gatherOffensesForRound(round?: bigint): Promise<Offense[]>;
+
+  /** Returns all pending offenses */
+  getPendingOffenses(): Promise<Offense[]>;
+
+  /**
+   * Update the configuration.
+   * Used by both Empire and Consensus models.
+   */
+  updateConfig(config: Partial<SlasherConfig>): void;
+
+  /**
+   * Get the actions the proposer should take for slashing.
+   * @param slotNumber - The current slot number
+   * @returns The actions to take
+   */
+  getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
+
+  /** Returns the current config */
+  getConfig(): SlasherConfig;
+}