@aztec-labs/slasher 6.0.0-nightly.20260829

package/src/factory/get_settings.ts

@@ -0,0 +1,58 @@
+import type { RollupContract, SlashingProposerContract } from '@aztec-labs/ethereum/contracts';
+
+import type { SlasherSettings } from '../slasher_client.js';
+
+export async function getSlasherSettings(
+  rollup: RollupContract,
+  slashingProposer?: SlashingProposerContract,
+): Promise<Omit<SlasherSettings, 'rollupRegisteredAtL2Slot'>> {
+  if (!slashingProposer) {
+    const rollupSlashingProposer = await rollup.getSlashingProposer();
+    if (!rollupSlashingProposer) {
+      throw new Error('Rollup slashing proposer not found');
+    }
+    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<SlasherSettings, '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 { getSlasherSettings } 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_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
+  SLASH_INACTIVITY_PENALTY: 10000000000000000000,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 10000000000000000000,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
+  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
+} as const;

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from './config.js';
+export * from './watchers/data_withholding_watcher.js';
+export * from './watchers/attestations_block_watcher.js';
+export * from './watchers/attested_invalid_proposal_watcher.js';
+export * from './watchers/broadcasted_invalid_checkpoint_proposal_watcher.js';
+export * from './watchers/checkpoint_equivocation_watcher.js';
+export * from './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-labs/stdlib/slashing';

package/src/metrics.ts

@@ -0,0 +1,58 @@
+import {
+  type Gauge,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} from '@aztec-labs/telemetry-client';
+import { formatEther } from 'viem/utils';
+
+export class SlasherMetrics {
+  private readonly roundExecuted: UpDownCounter;
+  private readonly ownValidatorTargeted: UpDownCounter;
+  private readonly ownValidatorSlashedCount: UpDownCounter;
+  private readonly ownValidatorSlashedAmount: UpDownCounter;
+  private readonly ownValidatorCurrentRoundVotesMax: Gauge;
+  private readonly quorumSize: Gauge;
+
+  constructor(client: TelemetryClient, name = 'Slasher') {
+    const meter = client.getMeter(name);
+    this.roundExecuted = createUpDownCounterWithDefault(meter, Metrics.SLASHER_ROUND_EXECUTED_COUNT);
+    this.ownValidatorTargeted = createUpDownCounterWithDefault(meter, Metrics.SLASHER_OWN_VALIDATOR_TARGETED_COUNT);
+    this.ownValidatorSlashedCount = createUpDownCounterWithDefault(meter, Metrics.SLASHER_OWN_VALIDATOR_SLASHED_COUNT);
+    this.ownValidatorSlashedAmount = createUpDownCounterWithDefault(
+      meter,
+      Metrics.SLASHER_OWN_VALIDATOR_SLASHED_AMOUNT,
+    );
+    this.ownValidatorCurrentRoundVotesMax = meter.createGauge(Metrics.SLASHER_OWN_VALIDATOR_CURRENT_ROUND_VOTES_MAX);
+    this.quorumSize = meter.createGauge(Metrics.SLASHER_QUORUM_SIZE);
+  }
+
+  public recordRoundExecuted(): void {
+    this.roundExecuted.add(1);
+  }
+
+  /** Records the quorum a validator must reach in a round to be slashed, so dashboards can plot the threshold. */
+  public recordQuorumSize(quorum: number): void {
+    this.quorumSize.record(quorum);
+  }
+
+  /** Records that an onchain slashing vote named one of the node's own validators as a target. */
+  public recordOwnValidatorTargeted(): void {
+    this.ownValidatorTargeted.add(1);
+  }
+
+  /**
+   * Records how close the most-voted committee position held by the node's own validators is to quorum this round.
+   * Recorded as an absolute value rather than a delta so a vote seen across a round rollover cannot make it drift.
+   */
+  public recordCurrentRoundVotesMax(votes: number): void {
+    this.ownValidatorCurrentRoundVotesMax.record(votes);
+  }
+
+  /** Records an executed slash against one of the node's own validators. */
+  public recordOwnValidatorSlashed(amount: bigint): void {
+    this.ownValidatorSlashedCount.add(1);
+    this.ownValidatorSlashedAmount.add(parseFloat(formatEther(amount)));
+  }
+}

package/src/null_slasher_client.ts

@@ -0,0 +1,37 @@
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { Offense, ProposerSlashAction } from '@aztec-labs/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 gatherOffensesForRound(_round?: bigint): Promise<Offense[]> {
+    return Promise.resolve([]);
+  }
+
+  public getOffenses(): 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/own_validator_slash_monitor.ts

@@ -0,0 +1,183 @@
+import type { SlashVoteTarget, SlashingProposerContract } from '@aztec-labs/ethereum/contracts';
+import { uniqueBy } from '@aztec-labs/foundation/collection';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import type { Hex } from 'viem';
+
+import type { SlasherMetrics } from './metrics.js';
+
+/**
+ * Watches slashing activity that targets the node's own validators: warns and counts on every vote naming one of
+ * them, tracks how close the current round's tally is to quorum, and reports executed slashes. Does nothing when
+ * the node runs no validators. Lifecycle calls must be sequential: start() before events are wired, and stop()
+ * awaited before any restart.
+ */
+export class OwnValidatorSlashMonitor {
+  /**
+   * Tally for the single round being tracked (votes are only ever cast for the current round). `nextVoteIndex` is
+   * the cursor: the index of the first vote in the round not yet processed, advanced from the indices the VoteCast
+   * events carry. It is undefined until the first event of a round that started mid-round, whose own vote is then
+   * the first one counted, so votes cast before the node subscribed are never replayed into the cumulative metrics.
+   * The tally is per flattened committee position because that is the unit the contract tallies quorum by.
+   */
+  private state: { round: bigint; nextVoteIndex: bigint | undefined; countByPosition: Map<number, number> } = {
+    round: -1n,
+    nextVoteIndex: undefined,
+    countByPosition: new Map(),
+  };
+
+  /**
+   * All vote processing runs through this queue, one job at a time in arrival order. Serialization is what makes
+   * the cursor sound: without it, concurrent event handlers could process the same index twice or emit warnings
+   * with out-of-order running tallies. Replaced on every start(), since a queue that has been ended cannot run
+   * jobs again.
+   */
+  private queue = new SerialQueue();
+
+  private stopped = false;
+
+  constructor(
+    private readonly slashingProposer: SlashingProposerContract,
+    private readonly settings: { slashingQuorumSize: number },
+    private readonly ownValidators: EthAddress[],
+    private readonly metrics: SlasherMetrics,
+    private readonly log = createLogger('slasher:own-validators'),
+  ) {
+    this.queue.start();
+  }
+
+  private get enabled(): boolean {
+    return this.ownValidators.length > 0;
+  }
+
+  /**
+   * Starts tracking at the given round, leaving the cursor unset so the round's votes already cast are skipped:
+   * replaying them would warn about votes the operator can no longer react to sooner, and would double-count
+   * cumulative counters across restarts.
+   */
+  public start(currentRound: bigint): void {
+    if (!this.enabled) {
+      return;
+    }
+    this.stopped = false;
+    this.queue = new SerialQueue();
+    this.queue.start();
+    this.state = { round: currentRound, nextVoteIndex: undefined, countByPosition: new Map() };
+    this.metrics.recordQuorumSize(this.settings.slashingQuorumSize);
+    this.metrics.recordCurrentRoundVotesMax(0);
+  }
+
+  /** Stops processing and waits for any in-flight drain, so no warning or metric is emitted after shutdown. */
+  public async stop(): Promise<void> {
+    this.stopped = true;
+    // Jobs already queued are no-ops now that the flag is set, so end() runs through them at no cost while still
+    // settling the promises their callers hold, where cancel() would discard them and leave those promises pending.
+    await this.queue.end();
+  }
+
+  /**
+   * Called by the round monitor clock. Strictly greater so the clock catching up to a round an event already rolled
+   * to keeps the tally.
+   */
+  public handleNewRound(round: bigint): void {
+    if (this.enabled && round > this.state.round) {
+      this.rollTo(round);
+    }
+  }
+
+  /**
+   * Called on each VoteCast event with the index the event carries. Reads every vote from the cursor up to that
+   * index, so an event delivery that never arrived is healed by the next one.
+   */
+  public handleVoteCast(round: bigint, voteIndex: bigint): Promise<void> {
+    if (!this.enabled || this.stopped) {
+      return Promise.resolve();
+    }
+    // Errors are logged rather than propagated: callers fire and forget, and a failed read is retried by the drain
+    // the next event triggers.
+    return this.queue
+      .put(() => this.drainVotesTo(round, voteIndex))
+      .catch(err => this.log.error('Error processing slashing votes', err));
+  }
+
+  /** Reports executed slashes against own validators. Called with the Slashed events already fetched by the client. */
+  public handleSlashes(round: bigint, slashes: { attester: EthAddress; amount: bigint }[], l1BlockHash: Hex): void {
+    if (!this.enabled || this.stopped) {
+      return;
+    }
+    for (const { attester, amount } of slashes.filter(slash => this.isOwnValidator(slash.attester))) {
+      this.log.warn(`Own validator ${attester} was slashed for ${amount}`, {
+        round,
+        validator: attester.toString(),
+        amount,
+        l1BlockHash,
+      });
+      this.metrics.recordOwnValidatorSlashed(amount);
+    }
+  }
+
+  /** Processes votes [cursor, voteIndex] of a round, in order, advancing the cursor after each success. */
+  private async drainVotesTo(round: bigint, voteIndex: bigint): Promise<void> {
+    if (this.stopped) {
+      return; // enqueued before stop() but not yet started: emit nothing and read nothing after shutdown
+    }
+    if (round < this.state.round) {
+      return; // a vote for a round that already closed can no longer reach quorum
+    }
+    if (round > this.state.round) {
+      this.rollTo(round); // the event beat the round-monitor clock to the boundary
+    }
+
+    // The first event of a round tracked from mid-round counts its own vote only: earlier ones predate the subscription
+    const from = this.state.nextVoteIndex ?? voteIndex;
+    if (voteIndex < from) {
+      return; // a duplicate or out-of-order delivery of a vote already processed
+    }
+
+    for (let index = from; index <= voteIndex; index++) {
+      const vote = await this.slashingProposer.getVoteAt(round, index);
+      if (this.stopped || round !== this.state.round) {
+        return; // stopped, or rolled mid-drain: either way this vote must no longer be counted
+      }
+      this.processVote(round, vote);
+      // Advanced only after successful processing, so a failed read is retried on the next event
+      this.state.nextVoteIndex = index + 1n;
+    }
+  }
+
+  private processVote(round: bigint, vote: SlashVoteTarget[]): void {
+    const own = vote.filter(target => this.isOwnValidator(target.validator));
+    for (const { position } of own) {
+      this.state.countByPosition.set(position, (this.state.countByPosition.get(position) ?? 0) + 1);
+    }
+
+    // Warn once per (vote, validator) at the validator's highest position tally: the operator cares about the
+    // validator, not which of its committee seats is being voted on. No slash amount (the amount voted is not
+    // necessarily the amount slashed) and no proposer (a catch-up drain cannot attribute votes to proposers).
+    const quorum = this.settings.slashingQuorumSize;
+    for (const { validator } of uniqueBy(own, target => target.validator.toString())) {
+      const votes = Math.max(
+        ...own.filter(t => t.validator.equals(validator)).map(t => this.state.countByPosition.get(t.position)!),
+      );
+      this.metrics.recordOwnValidatorTargeted();
+      this.log.warn(
+        `Own validator ${validator} targeted by slashing vote (${votes} of ${quorum} votes needed to slash)`,
+        { round, validator: validator.toString(), votes, quorum },
+      );
+    }
+
+    this.metrics.recordCurrentRoundVotesMax(Math.max(0, ...this.state.countByPosition.values()));
+  }
+
+  /** Starts a fresh tally, zeroing the gauge so a quiet round does not keep the previous round's value. */
+  private rollTo(round: bigint): void {
+    this.state = { round, nextVoteIndex: 0n, countByPosition: new Map() };
+    this.metrics.recordCurrentRoundVotesMax(0);
+    this.metrics.recordQuorumSize(this.settings.slashingQuorumSize); // keeps the gauge fresh across export cycles
+  }
+
+  private isOwnValidator(address: EthAddress): boolean {
+    return this.ownValidators.some(validator => validator.equals(address));
+  }
+}

package/src/slash_offenses_collector.ts

@@ -0,0 +1,156 @@
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import type { Prettify } from '@aztec-labs/foundation/types';
+import type { L1RollupConstants } from '@aztec-labs/stdlib/epoch-helpers';
+import type { SlasherConfig } from '@aztec-labs/stdlib/interfaces/server';
+import { type Offense, getOffenseTypeName, getSlotForOffense } from '@aztec-labs/stdlib/slashing';
+
+import type { SlasherOffensesStore } from './stores/offenses_store.js';
+import {
+  WANT_TO_CLEAR_SLASH_EVENT,
+  WANT_TO_SLASH_EVENT,
+  type WantToClearSlashArgs,
+  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)[] = [];
+  private readonly storeMutationQueue = new SerialQueue();
+
+  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...');
+    this.storeMutationQueue.start();
+
+    // Subscribe to watcher slashing events.
+    for (const watcher of this.watchers) {
+      const wantToSlashCallback = (args: WantToSlashArgs[]) =>
+        this.enqueueStoreMutation('wantToSlash', () => this.handleWantToSlash(args));
+      watcher.on(WANT_TO_SLASH_EVENT, wantToSlashCallback);
+      this.unwatchCallbacks.push(() => watcher.removeListener(WANT_TO_SLASH_EVENT, wantToSlashCallback));
+
+      const wantToClearSlashCallback = (args: WantToClearSlashArgs[]) =>
+        this.enqueueStoreMutation('wantToClearSlash', () => this.handleWantToClearSlash(args));
+      watcher.on(WANT_TO_CLEAR_SLASH_EVENT, wantToClearSlashCallback);
+      this.unwatchCallbacks.push(() => watcher.removeListener(WANT_TO_CLEAR_SLASH_EVENT, wantToClearSlashCallback));
+    }
+
+    this.log.info('Started SlashOffensesCollector');
+    return Promise.resolve();
+  }
+
+  public async stop() {
+    this.log.debug('Stopping SlashOffensesCollector...');
+
+    for (const unwatchCallback of this.unwatchCallbacks) {
+      unwatchCallback();
+    }
+
+    await this.storeMutationQueue.end();
+
+    this.log.info('SlashOffensesCollector stopped');
+  }
+
+  /**
+   * 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 offense: Offense = {
+        validator: arg.validator,
+        amount: arg.amount,
+        offenseType: arg.offenseType,
+        epochOrSlot: arg.epochOrSlot,
+      };
+
+      if (this.shouldSkipOffense(offense)) {
+        this.log.verbose('Skipping offense during grace period', this.getOffenseLogData(offense));
+        continue;
+      }
+
+      const added = await this.offensesStore.addOffense(offense);
+      if (added) {
+        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.getOffenseLogData(offense),
+            );
+          }
+        }
+
+        this.log.info(`Adding pending offense for validator ${arg.validator}`, this.getOffenseLogData(offense));
+      } else {
+        this.log.debug('Skipping repeated offense', this.getOffenseLogData(offense));
+      }
+    }
+  }
+
+  public async handleWantToClearSlash(args: WantToClearSlashArgs[]) {
+    for (const arg of args) {
+      const cleared = await this.offensesStore.clearOffenses(arg);
+      if (cleared > 0) {
+        this.log.info(`Cleared ${cleared} pending offenses`, {
+          offenseType: getOffenseTypeName(arg.offenseType),
+          epochOrSlot: arg.epochOrSlot,
+          validators: arg.validators?.map(validator => validator.toString()),
+        });
+      }
+    }
+  }
+
+  /**
+   * 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}`);
+    }
+  }
+
+  /** 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;
+  }
+
+  private getOffenseLogData(offense: Offense) {
+    return {
+      ...offense,
+      validator: offense.validator.toString(),
+      offenseType: getOffenseTypeName(offense.offenseType),
+    };
+  }
+
+  private enqueueStoreMutation(label: string, callback: () => Promise<void>) {
+    void this.storeMutationQueue.put(callback).catch(err => this.log.error(`Error handling ${label}`, err));
+  }
+}

package/src/slash_round_monitor.ts

@@ -0,0 +1,62 @@
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { createLogger } from '@aztec-labs/foundation/log';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { Prettify } from '@aztec-labs/foundation/types';
+import { type L1RollupConstants, getSlotAtTimestamp } from '@aztec-labs/stdlib/epoch-helpers';
+import { getRoundForSlot } from '@aztec-labs/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);
+  }
+}