@aztec/slasher 0.0.1-commit.001888fc

package/src/factory/create_facade.ts

@@ -0,0 +1,82 @@
+import { EpochCache } from '@aztec/epoch-cache';
+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 { 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';
+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' | 'registryAddress'>,
+  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, 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);
+  const updatedConfig = { ...config, slashValidatorsNever };
+
+  return new SlasherClientFacade(
+    updatedConfig,
+    rollup,
+    l1Client,
+    l1Contracts.slashFactoryAddress,
+    watchers,
+    epochCache,
+    dateProvider,
+    kvStore,
+    rollupRegisteredAtL2Slot,
+    logger,
+  );
+}

package/src/factory/create_implementation.ts

@@ -0,0 +1,184 @@
+import { EpochCache } from '@aztec/epoch-cache';
+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 { 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';
+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,
+  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,
+      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,
+      rollupRegisteredAtL2Slot,
+      logger,
+    );
+  }
+}
+
+async function createEmpireSlasher(
+  config: SlasherConfig & DataStoreConfig & { ethereumSlotDuration: number },
+  rollup: RollupContract,
+  slashingProposer: EmpireSlashingProposerContract,
+  slashFactoryContract: SlashFactoryContract,
+  watchers: Watcher[],
+  dateProvider: DateProvider,
+  kvStore: AztecLMDBStoreV2,
+  rollupRegisteredAtL2Slot: SlotNumber,
+  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,
+    rollupRegisteredAtL2Slot,
+  };
+
+  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,
+  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)), rollupRegisteredAtL2Slot };
+  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/contracts';
+
+import type { TallySlasherSettings } from '../tally_slasher_client.js';
+
+export async function getTallySlasherSettings(
+  rollup: RollupContract,
+  slashingProposer?: TallySlashingProposerContract,
+): Promise<Omit<TallySlasherSettings, 'rollupRegisteredAtL2Slot'>> {
+  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: Omit<TallySlasherSettings, 'rollupRegisteredAtL2Slot'> = {
+    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/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/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,123 @@
+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 { 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;
+    /** L2 slot at which the rollup was registered as canonical in the Registry. Used to anchor the slash grace period. */
+    rollupRegisteredAtL2Slot: SlotNumber;
+  }
+>;
+
+/**
+ * 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 after the network upgrade */
+  private shouldSkipOffense(offense: Offense): boolean {
+    const offenseSlot = getSlotForOffense(offense, this.settings);
+    return offenseSlot < this.settings.rollupRegisteredAtL2Slot + 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);
+  }
+}