@aztec/slasher 0.0.1-commit.85d7d01 → 0.0.1-commit.8655d4a

package/src/watchers/checkpoint_equivocation_watcher.ts

@@ -0,0 +1,96 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { merge, pick } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import {
+  type CheckpointEquivocationDetectedEvent,
+  type L2BlockSourceEventEmitter,
+  L2BlockSourceEvents,
+} from '@aztec/stdlib/block';
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
+
+import EventEmitter from 'node:events';
+
+import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
+
+const CheckpointEquivocationWatcherConfigKeys = ['slashDuplicateProposalPenalty'] as const;
+
+type CheckpointEquivocationWatcherConfig = Pick<
+  SlasherConfig,
+  (typeof CheckpointEquivocationWatcherConfigKeys)[number]
+>;
+
+type EquivocationEventSource = Pick<L2BlockSourceEventEmitter, 'events'>;
+type ProposerLookup = Pick<EpochCacheInterface, 'getProposerAttesterAddressInSlot'>;
+
+/**
+ * Slashes the slot proposer for DUPLICATE_PROPOSAL when the archiver detects that a
+ * locally-stored proposed checkpoint disagrees with the L1-confirmed checkpoint at the
+ * same slot. Both are signed by the slot proposer (the proposed one by accepting it via
+ * P2P or building it locally; the L1 one by submission), so the proposer equivocated.
+ */
+export class CheckpointEquivocationWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
+  private readonly log: Logger = createLogger('checkpoint-equivocation-watcher');
+  private readonly handler: (args: CheckpointEquivocationDetectedEvent) => void;
+  private config: CheckpointEquivocationWatcherConfig;
+
+  constructor(
+    private readonly l2BlockSource: EquivocationEventSource,
+    private readonly epochCache: ProposerLookup,
+    config: CheckpointEquivocationWatcherConfig,
+  ) {
+    super();
+    this.config = pick(config, ...CheckpointEquivocationWatcherConfigKeys);
+    this.handler = event => {
+      this.onEquivocationDetected(event).catch(err =>
+        this.log.error('Failed to handle checkpoint equivocation event', err),
+      );
+    };
+    this.log.info('CheckpointEquivocationWatcher initialized');
+  }
+
+  public updateConfig(config: Partial<CheckpointEquivocationWatcherConfig>): void {
+    this.config = merge(this.config, pick(config, ...CheckpointEquivocationWatcherConfigKeys));
+    this.log.verbose('CheckpointEquivocationWatcher config updated', this.config);
+  }
+
+  public start(): Promise<void> {
+    this.l2BlockSource.events.on(L2BlockSourceEvents.CheckpointEquivocationDetected, this.handler);
+    return Promise.resolve();
+  }
+
+  public stop(): Promise<void> {
+    this.l2BlockSource.events.off(L2BlockSourceEvents.CheckpointEquivocationDetected, this.handler);
+    return Promise.resolve();
+  }
+
+  /** Public for tests. */
+  public async onEquivocationDetected(event: CheckpointEquivocationDetectedEvent): Promise<void> {
+    const proposer = await this.epochCache.getProposerAttesterAddressInSlot(event.slotNumber);
+    if (!proposer) {
+      this.log.warn(`Cannot attribute checkpoint equivocation: no proposer for slot ${event.slotNumber}`, {
+        slotNumber: event.slotNumber,
+        checkpointNumber: event.checkpointNumber,
+      });
+      return;
+    }
+
+    const slashArgs: WantToSlashArgs = {
+      validator: proposer,
+      amount: this.config.slashDuplicateProposalPenalty,
+      offenseType: OffenseType.DUPLICATE_PROPOSAL,
+      epochOrSlot: BigInt(event.slotNumber),
+    };
+
+    this.log.info(`Detected checkpoint equivocation offense`, {
+      slotNumber: event.slotNumber,
+      checkpointNumber: event.checkpointNumber,
+      amount: slashArgs.amount,
+      offenseType: getOffenseTypeName(slashArgs.offenseType),
+      l1ArchiveRoot: event.l1ArchiveRoot.toString(),
+      proposedArchiveRoot: event.proposedArchiveRoot.toString(),
+      validator: proposer.toString(),
+    });
+    this.emit(WANT_TO_SLASH_EVENT, [slashArgs]);
+  }
+}

package/src/watchers/data_withholding_watcher.ts

@@ -0,0 +1,225 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import { CheckpointProposalHash, SlotNumber } from '@aztec/foundation/branded-types';
+import { compactArray, merge, pick } from '@aztec/foundation/collection';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { getAttestationInfoFromPublishedCheckpoint } from '@aztec/stdlib/block';
+import type { CheckpointReexecutionTracker, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { ITxProvider, P2PApi, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import { ConsensusPayload, type CoordinationSignatureContext } from '@aztec/stdlib/p2p';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import EventEmitter from 'node:events';
+
+import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
+
+const DataWithholdingWatcherConfigKeys = ['slashDataWithholdingPenalty', 'slashDataWithholdingToleranceSlots'] as const;
+
+type DataWithholdingWatcherConfig = Pick<SlasherConfig, (typeof DataWithholdingWatcherConfigKeys)[number]>;
+
+/**
+ * Detects data-withholding offenses by probing the local mempool for the txs in published
+ * checkpoints once they are old enough that an honest node should have collected them.
+ *
+ * Per AZIP-7: once `slashDataWithholdingToleranceSlots` full slots have elapsed after the
+ * checkpoint's slot — i.e. at `slotStart(checkpoint.slot + slashDataWithholdingToleranceSlots
+ * + 1)` — if any tx from the checkpoint's blocks is still missing locally, the checkpoint's
+ * attesters are considered at fault for not making the data available, and we emit a slash
+ * for them.
+ *
+ * The watcher ticks at quarter-eth-slot cadence (matching the Sentinel template). On boot it
+ * floors processing at the current slot — restart-time gaps are accepted and not back-filled,
+ * matching the Sentinel approach.
+ */
+export class DataWithholdingWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
+  private runningPromise: RunningPromise;
+  private initialSlot: SlotNumber | undefined;
+  private lastCheckedSlot: SlotNumber | undefined;
+  private config: DataWithholdingWatcherConfig;
+
+  constructor(
+    private readonly epochCache: EpochCache,
+    private readonly l2BlockSource: Pick<L2BlockSource, 'getCheckpoint' | 'getSyncedL2SlotNumber'>,
+    private readonly txProvider: Pick<ITxProvider, 'hasTxs'>,
+    private readonly p2p: Pick<P2PApi, 'getCheckpointAttestationsForSlot'>,
+    private readonly reexecutionTracker: Pick<CheckpointReexecutionTracker, 'getTxsCollectedRecord'>,
+    private readonly signatureContext: CoordinationSignatureContext,
+    config: DataWithholdingWatcherConfig,
+    private readonly log: Logger = createLogger('data-withholding-watcher'),
+  ) {
+    super();
+    this.config = pick(config, ...DataWithholdingWatcherConfigKeys);
+    const interval = (epochCache.getL1Constants().ethereumSlotDuration * 1000) / 4;
+    this.runningPromise = new RunningPromise(this.work.bind(this), log, interval);
+    this.log.verbose(`DataWithholdingWatcher initialized`, this.config);
+  }
+
+  public async start(): Promise<void> {
+    // Floor processing at the archiver's synced slot rather than the wallclock — restart-time
+    // gaps before the archiver catches up are accepted and not back-filled. Falls back to the
+    // wallclock if the archiver isn't ready yet (cold start).
+    const syncedSlot = await this.l2BlockSource.getSyncedL2SlotNumber();
+    this.initialSlot = syncedSlot ?? this.epochCache.getSlotNow();
+    this.log.info(`Starting data-withholding watcher with initial slot ${this.initialSlot}`);
+    this.runningPromise.start();
+  }
+
+  public stop(): Promise<void> {
+    return this.runningPromise.stop();
+  }
+
+  public updateConfig(config: Partial<SlasherConfig>): void {
+    this.config = merge(this.config, pick(config, ...DataWithholdingWatcherConfigKeys));
+    this.log.verbose('DataWithholdingWatcher config updated', this.config);
+  }
+
+  /**
+   * Runs every tick. Walks newly-eligible slots and probes their checkpoints for data
+   * availability; emits a DATA_WITHHOLDING slash for any checkpoint whose txs are missing.
+   */
+  public async work(): Promise<void> {
+    if (this.initialSlot === undefined) {
+      return;
+    }
+
+    // tolerance is the number of full slots that must elapse after the checkpoint's slot
+    // before we declare its data missing. For checkpoint slot S, we therefore process S
+    // only once we are in slot `S + tolerance + 1` or later. Drive this off the archiver's
+    // synced slot rather than the wallclock so we don't make claims about slots we haven't
+    // fully ingested yet (archiver may lag behind L1).
+    const tolerance = this.config.slashDataWithholdingToleranceSlots;
+    const currentSlot = (await this.l2BlockSource.getSyncedL2SlotNumber()) ?? this.epochCache.getSlotNow();
+    if (currentSlot <= tolerance) {
+      return;
+    }
+
+    const targetSlot = SlotNumber(currentSlot - tolerance - 1);
+    if (targetSlot <= this.initialSlot) {
+      return;
+    }
+
+    const startSlot = this.lastCheckedSlot === undefined ? this.initialSlot : this.lastCheckedSlot;
+    for (let slot = SlotNumber(startSlot + 1); slot <= targetSlot; slot = SlotNumber(slot + 1)) {
+      try {
+        await this.processSlot(slot);
+      } catch (err) {
+        this.log.error(`Error processing slot ${slot} for data-withholding check`, err, { slot });
+      }
+      this.lastCheckedSlot = slot;
+    }
+  }
+
+  /** Probes the checkpoint at the given slot, if any, and emits a slash on missing txs. */
+  private async processSlot(slot: SlotNumber): Promise<void> {
+    const published = await this.l2BlockSource.getCheckpoint({ slot });
+    if (!published) {
+      this.log.trace(`No published checkpoint at slot ${slot}`, { slot });
+      return;
+    }
+
+    const checkpointNumber = published.checkpoint.number;
+
+    // Per-block tx-collection records (true | false | undefined) for every block in this
+    // published checkpoint. Captured by the validator's proposal handler at the moment of
+    // tx collection (i.e. by the *re-execution* deadline). Used as a positive short-circuit
+    // only: a `true` for every block means we know the data was available locally, so this
+    // checkpoint cannot be a data-withholding offense. A `false` does *not* trigger a slash
+    // on its own — the re-execution deadline is much earlier than the data-withholding
+    // tolerance window, so missing txs at that earlier deadline may still arrive in time.
+    // Anything other than all-true falls through to the mempool probe, which respects the
+    // tolerance window.
+    const collectionRecords = published.checkpoint.blocks.map((block, idx) =>
+      this.reexecutionTracker.getTxsCollectedRecord(block.header.getSlot(), idx),
+    );
+
+    if (collectionRecords.every(r => r === true)) {
+      this.log.trace(`All blocks for checkpoint at slot ${slot} were collected locally; skipping`, {
+        slot,
+        checkpointNumber,
+      });
+      return;
+    }
+
+    const txHashes: TxHash[] = published.checkpoint.blocks.flatMap(block =>
+      block.body.txEffects.map(txEffect => txEffect.txHash),
+    );
+
+    if (txHashes.length === 0) {
+      this.log.trace(`Checkpoint at slot ${slot} has no txs`, { slot });
+      return;
+    }
+
+    const availability = await this.txProvider.hasTxs(txHashes);
+    const missingTxs = txHashes.filter((_, i) => !availability[i]);
+    if (missingTxs.length === 0) {
+      this.log.trace(`All ${txHashes.length} txs available for checkpoint at slot ${slot}`, { slot });
+      return;
+    }
+
+    const attesters = await this.extractAttesters(published);
+
+    if (attesters.length === 0) {
+      this.log.warn(`Detected data withholding at slot ${slot} but no recoverable attesters`, {
+        slot,
+        checkpointNumber,
+        missingTxs: missingTxs.map(h => h.toString()),
+        records: collectionRecords,
+      });
+      return;
+    }
+
+    this.log.info(`Detected data withholding offense at slot ${slot}`, {
+      slot,
+      checkpointNumber,
+      amount: this.config.slashDataWithholdingPenalty,
+      offenseType: getOffenseTypeName(OffenseType.DATA_WITHHOLDING),
+      missingTxs: missingTxs.map(h => h.toString()),
+      records: collectionRecords,
+      attesters: attesters.map(a => a.toString()),
+    });
+
+    const args: WantToSlashArgs[] = attesters.map(validator => ({
+      validator,
+      amount: this.config.slashDataWithholdingPenalty,
+      offenseType: OffenseType.DATA_WITHHOLDING,
+      epochOrSlot: BigInt(slot),
+    }));
+    this.emit(WANT_TO_SLASH_EVENT, args);
+  }
+
+  /**
+   * Returns the union of:
+   *   1. attesters whose signatures landed in the published checkpoint on L1, and
+   *   2. attesters we observed signing the same proposal on p2p (the proposer publishes as
+   *      soon as it has hit committee quorum, so honest peer attestations that arrive after
+   *      that point are dropped — but they still vouched for the data and
+   *      should be slashed for withholding it).
+   *
+   *
+   * Exposed as protected so tests can substitute a deterministic recovery without having
+   * to construct real secp256k1 signatures.
+   */
+  protected async extractAttesters(published: PublishedCheckpoint): Promise<EthAddress[]> {
+    const fromL1 = getAttestationInfoFromPublishedCheckpoint(published, this.signatureContext)
+      .filter(info => info.status === 'recovered-from-signature')
+      .map(info => info.address);
+
+    const slot = published.checkpoint.header.slotNumber;
+    const proposalPayloadHash = CheckpointProposalHash.fromBuffer(
+      ConsensusPayload.fromCheckpoint(published.checkpoint, this.signatureContext).getPayloadHash(),
+    );
+    const fromP2p = await this.p2p
+      .getCheckpointAttestationsForSlot(slot, proposalPayloadHash)
+      .then(attestations => attestations.map(a => a.getSender()));
+
+    // Dedupe
+    const all = new Map<string, EthAddress>();
+    for (const addr of compactArray([...fromL1, ...fromP2p])) {
+      all.set(addr.toString(), addr);
+    }
+    return [...all.values()];
+  }
+}

package/dest/empire_slasher_client.d.ts

@@ -1,190 +0,0 @@
-import { EmpireSlashingProposerContract, RollupContract, SlasherContract } from '@aztec/ethereum/contracts';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import type { DateProvider } from '@aztec/foundation/timer';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
-import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-import { type Offense, type ProposerSlashAction, type ProposerSlashActionProvider, type SlashPayload, type SlashPayloadRound } from '@aztec/stdlib/slashing';
-import { type SlashOffensesCollectorSettings } from './slash_offenses_collector.js';
-import type { SlasherClientInterface } from './slasher_client_interface.js';
-import type { SlasherOffensesStore } from './stores/offenses_store.js';
-import type { SlasherPayloadsStore } from './stores/payloads_store.js';
-import type { Watcher } from './watcher.js';
-/** Used to track executable payloads for each round */
-export type PayloadWithRound = {
-    payload: EthAddress;
-    round: bigint;
-};
-/** Node configuration for the empire slasher */
-export type EmpireSlasherConfig = SlasherConfig;
-/** Settings used in the empire slasher client, loaded from the L1 contracts during initialization */
-export type EmpireSlasherSettings = {
-    slashingExecutionDelayInRounds: number;
-    slashingPayloadLifetimeInRounds: number;
-    slashingRoundSize: number;
-    slashingQuorumSize: number;
-} & Pick<L1RollupConstants, 'epochDuration' | 'proofSubmissionEpochs' | 'l1GenesisTime' | 'slotDuration' | 'l1StartBlock' | 'ethereumSlotDuration'> & SlashOffensesCollectorSettings;
-/**
- * The Empire Slasher client is responsible for managing slashable offenses and slash payloads
- * using the Empire slashing model where fixed payloads are created and voted on.
- *
- * The client subscribes to several slash watchers that emit offenses and tracks them. When the slasher is the
- * proposer, it aggregates pending offenses from previous rounds and creates slash payloads, or votes for previous
- * slash payloads.
- * Voting is handled by the sequencer publisher, the slasher client does not interact with L1 directly.
- * The client also monitors slash payloads created by other nodes, and executes them when they become submittable.
- *
- * Payload creation and selection
- * - At each L2 slot in a slashing round, the proposer for that L2 slot may vote for an existing slashing payload or
- * create one of their own. Note that anyone can create a slash payload on L1, but nodes will only follow payloads
- * from proposers; we could enforce this on L1, but we do not want to make any changes there if we can avoid it.
- * - If it is the first L2 slot in the slashing round, there is nothing to vote for, so the proposer creates a slash
- * payload and votes for it.
- * - On their turn, each proposer computes a score for each payload in the round. This score is a function of the
- * total offences slashed, how many votes it has received so far, and how far into the round we are. The score for a
- * payload is zero if the proposer disagrees with it (see "agreement" below).
- * - The proposer also computes the score for the payload they would create. If the resulting score is higher than
- * any existing payload, it creates the payload. Otherwise, it votes for the one with the highest score.
- *
- * Collecting offences
- * - Whenever a node spots a slashable offence, they store it and add it to a local collection of "pending
- * offences". When a proposer needs to create a slash payload, they include all pending offences from previous
- * rounds. This means an offence is **only slashable in the next round it happened** (or a future one).
- * - Each offence also carries an epoch or block identifier, so we can differentiate two offences of the same kind by
- * the same validator.
- * - When a slash payload is flagged as executable (as in it got enough votes to be executed), nodes remove all
- * slashed offences in the payload from their collection of pending offences.
- * - Pending offences expire after a configurable time. This is to minimize divergences. For instance, a validator
- * that has to be slashed due to inactivity 50 epochs ago will only be considered for slashing by nodes that were
- * online 50 epochs ago. We propose using the validator exit window as expiration time, any value higher means that
- * we may try slashing validators that have exited the set already.
- *
- * Agreement and scoring
- * - A proposer will *agree* with a slash payload if it *agrees* with every offence in the payload, all
- * *uncontroversial* offences from the past round are included, and it is below a configurable maximum size.
- * - An *uncontroversial* offence is one where every node agrees that a slash is in order, regardless of any p2p
- * network partitions. The only uncontroversial offence we have now is "proposing a block on L1 with invalid
- * attestations".
- * - A proposer will *agree* with a given offence if it is present in its list of "pending offences", and the
- * slashing amount is within a configurable min-max range.
- * - Slash payloads need a maximum size to ensure they can don't exceed the maximum L1 gas per tx when executed.
- * This is configurable but depends on the L1 contracts implementation. When creating a payload, if there are too
- * many pending offences to fit, proposers favor the offences with the highest slashing amount first, tie-breaking by
- * choosing the most recent ones.
- * - The scoring function will boost proposals with more agreed slashes, as well as proposals with more votes, and
- * will disincentivize the creation of new proposals as the end of the round nears. This function will NOT be
- * enforced on L1.
- *
- * Execution
- * - Once a slash payload becomes executable, the next proposer is expected to execute it. If they don't, the
- * following does, and so on. No gas rebate is given.
- */
-export declare class EmpireSlasherClient implements ProposerSlashActionProvider, SlasherClientInterface {
-    private config;
-    private settings;
-    private slashFactoryContract;
-    private slashingProposer;
-    private slasher;
-    private rollup;
-    private dateProvider;
-    private offensesStore;
-    private payloadsStore;
-    private log;
-    protected executablePayloads: PayloadWithRound[];
-    private unwatchCallbacks;
-    private overridePayloadActive;
-    private offensesCollector;
-    private roundMonitor;
-    constructor(config: EmpireSlasherConfig, settings: EmpireSlasherSettings, slashFactoryContract: SlashFactoryContract, slashingProposer: EmpireSlashingProposerContract, slasher: SlasherContract, rollup: RollupContract, watchers: Watcher[], dateProvider: DateProvider, offensesStore: SlasherOffensesStore, payloadsStore: SlasherPayloadsStore, log?: import("@aztec/foundation/log").Logger);
-    start(): Promise<void>;
-    /**
-     * Allows consumers to stop the instance of the slasher client.
-     * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
-     */
-    stop(): Promise<void>;
-    /** Returns the current config */
-    getConfig(): EmpireSlasherConfig;
-    /**
-     * Update the config of the slasher client
-     * @param config - The new config
-     */
-    updateConfig(config: Partial<SlasherConfig>): void;
-    getSlashPayloads(): Promise<SlashPayloadRound[]>;
-    /**
-     * Triggered on a time basis when we enter a new slashing round.
-     * Clears expired payloads and offenses from stores.
-     */
-    protected handleNewRound(round: bigint): Promise<void>;
-    /**
-     * Called when we see a PayloadSubmittable event on the SlashProposer.
-     * Adds the proposal to the list of executable ones.
-     */
-    protected handleProposalExecutable(payloadAddress: EthAddress, round: bigint): Promise<void>;
-    /**
-     * Called when we see a PayloadSubmitted event on the SlashProposer.
-     * Removes the proposal from the list of executable ones.
-     */
-    protected handleProposalExecuted(payload: EthAddress, round: bigint): Promise<void>;
-    /**
-     * Called when we see a SignalCast event on the SlashProposer.
-     * Adds a vote for the given payload in the round.
-     * Retrieves the proposal if we have not seen it before.
-     */
-    protected handleProposalSignalled(payloadAddress: EthAddress, round: bigint, signaller: EthAddress): Promise<void>;
-    /**
-     * Create a slash payload for the given round from pending offenses
-     * @param round - The round to create the payload for, defaults to the current round
-     * @returns The payload data or undefined if no offenses to slash
-     */
-    gatherOffensesForRound(round?: bigint): Promise<Offense[]>;
-    /** Returns all pending offenses stored */
-    getPendingOffenses(): Promise<Offense[]>;
-    /** Get uncontroversial offenses that are expected to be present on the given round. */
-    protected getPendingUncontroversialOffensesForRound(round: bigint): Promise<Offense[]>;
-    /**
-     * Calculate score for a slash payload, bumping the votes by one, so we get the score as if we voted for it.
-     * @param payload - The payload to score
-     * @param votes - Number of votes the payload has received
-     * @returns The score for the payload
-     */
-    protected calculatePayloadScore(payload: Pick<SlashPayloadRound, 'votes' | 'slashes'>): bigint;
-    /**
-     * 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 an execute payload action if there are any payloads ready to be executed */
-    protected getExecutePayloadAction(slotNumber: SlotNumber): Promise<ProposerSlashAction | undefined>;
-    /** Returns a vote or create payload action based on payload scoring */
-    protected getProposePayloadActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
-    /**
-     * Check if we agree with a payload:
-     * - We must agree with every offense in the payload
-     * - All uncontroversial offenses from past rounds must be included
-     * - Payload must be below maximum size
-     * - Slash amounts must be within acceptable ranges
-     */
-    protected agreeWithPayload(payload: SlashPayload, round: bigint, cachedUncontroversialOffenses?: Offense[]): Promise<boolean>;
-    /**
-     * Returns whether the given offense can be included in the given round.
-     * Depends on the offense round range and whether we include offenses from past rounds.
-     */
-    private isOffenseForRound;
-    /**
-     * Returns the range (inclusive) of rounds in which we could expect an offense to be found.
-     * Lower bound is determined by all offenses that should have been captured before the start of a round,
-     * which depends on the offense type (eg INACTIVITY is captured once an epoch ends, DATA_WITHHOLDING is
-     * captured after the epoch proof submission window for the epoch for which the data was withheld).
-     * Upper bound is determined by the expiration rounds for an offense, which is a config setting.
-     */
-    private getRoundRangeForOffense;
-    /** Returns the acceptable range for slash amount given a set of offenses. */
-    private getSlashAmountValidRange;
-    /** Get minimum acceptable amount for an offense type */
-    private getMinAmountForOffense;
-    /** Get maximum acceptable amount for an offense type */
-    private getMaxAmountForOffense;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/empire_slasher_client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"empire_slasher_client.d.ts","sourceRoot":"","sources":["../src/empire_slasher_client.ts"],"names":[],"mappings":"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"}