@aztec/slasher 0.0.1-commit.ec5f612 → 0.0.1-commit.ec7ac5448

package/src/{tally_slasher_client.ts → slasher_client.ts}

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

package/src/slasher_client_facade.ts

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

package/src/slasher_client_interface.ts

@@ -1,11 +1,8 @@
 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';
+import type { Offense, ProposerSlashAction } from '@aztec/stdlib/slashing';
 
-/**
- * Common interface for slasher clients used by the Aztec node.
- * Both Empire and Consensus slasher clients implement this interface.
- */
+/** Common interface for slasher clients used by the Aztec node. */
 export interface SlasherClientInterface {
   /** Start the slasher client */
   start(): Promise<void>;
@@ -13,25 +10,13 @@ export interface SlasherClientInterface {
   /** 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.
-   */
+  /** Gather offenses for a given round, defaults to current. */
   gatherOffensesForRound(round?: bigint): Promise<Offense[]>;
 
-  /** Returns all pending offenses */
-  getPendingOffenses(): Promise<Offense[]>;
+  /** Returns all offenses */
+  getOffenses(): Promise<Offense[]>;
 
-  /**
-   * Update the configuration.
-   * Used by both Empire and Consensus models.
-   */
+  /** Update the configuration. */
   updateConfig(config: Partial<SlasherConfig>): void;
 
   /**

package/src/stores/offenses_store.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/aztec.js/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSet } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import {
   type Offense,
   type OffenseIdentifier,
@@ -14,10 +14,7 @@ export class SlasherOffensesStore {
   /** Map from offense key to offense data */
   private offenses: AztecAsyncMap<string, Buffer>;
 
-  /** Map from offense key to whether the offense has been executed (only used for empire based slashing) */
-  private offensesSlashed: AztecAsyncSet<string>;
-
-  /** Multimap from round to offense keys (only used for consensus based slashing) */
+  /** Multimap from round to offense keys */
   private roundsOffenses: AztecAsyncMultiMap<string, string>;
 
   private log = createLogger('slasher:store:offenses');
@@ -32,18 +29,13 @@ export class SlasherOffensesStore {
   ) {
     this.offenses = kvStore.openMap('offenses');
     this.roundsOffenses = kvStore.openMultiMap('rounds-offenses');
-    this.offensesSlashed = kvStore.openSet('offenses-slashed');
   }
 
-  /** Returns all offenses not marked as slashed */
-  public async getPendingOffenses(): Promise<Offense[]> {
+  /** Returns all offenses */
+  public async getOffenses(): Promise<Offense[]> {
     const offenses: Offense[] = [];
-    for await (const [key, buffer] of this.offenses.entriesAsync()) {
-      if (await this.offensesSlashed.hasAsync(key)) {
-        continue; // Skip executed offenses
-      }
-      const offense = deserializeOffense(buffer);
-      offenses.push(offense);
+    for await (const [, buffer] of this.offenses.entriesAsync()) {
+      offenses.push(deserializeOffense(buffer));
     }
     return offenses;
   }
@@ -61,20 +53,14 @@ export class SlasherOffensesStore {
     return offenses;
   }
 
-  /** Returns whether an offense is pending (ie not marked as slashed) */
-  public async hasPendingOffense(offense: OffenseIdentifier): Promise<boolean> {
-    const key = this.getOffenseKey(offense);
-    return (await this.offenses.getAsync(key)) !== undefined && !(await this.offensesSlashed.hasAsync(key));
-  }
-
   /** Returns whether we have seen this offense */
   public async hasOffense(offense: OffenseIdentifier): Promise<boolean> {
     const key = this.getOffenseKey(offense);
     return (await this.offenses.getAsync(key)) !== undefined;
   }
 
-  /** Adds a new offense (defaults to pending, but will be slashed if markAsSlashed had been called for it) */
-  public async addPendingOffense(offense: Offense): Promise<void> {
+  /** Adds a new offense */
+  public async addOffense(offense: Offense): Promise<void> {
     const key = this.getOffenseKey(offense);
     const round = getRoundForOffense(offense, this.settings);
     await this.kvStore.transactionAsync(async () => {
@@ -84,16 +70,6 @@ export class SlasherOffensesStore {
     this.log.trace(`Adding pending offense ${key} for round ${round}`);
   }
 
-  /** Marks the given offenses as slashed (regardless of whether they are known or not)  */
-  public async markAsSlashed(offenses: OffenseIdentifier[]): Promise<void> {
-    await this.kvStore.transactionAsync(async () => {
-      for (const offense of offenses) {
-        const key = this.getOffenseKey(offense);
-        await this.offensesSlashed.add(key);
-      }
-    });
-  }
-
   /** Prunes all offenses expired from the store */
   public async clearExpiredOffenses(currentRound: bigint): Promise<number> {
     const expirationRounds = this.settings.slashOffenseExpirationRounds ?? 0;
@@ -125,7 +101,6 @@ export class SlasherOffensesStore {
       for (const key of expiredOffenseKeys) {
         this.log.trace(`Deleting offense ${key}`);
         await this.offenses.delete(key);
-        await this.offensesSlashed.delete(key);
       }
       for (const roundKey of expiredRoundKeys) {
         this.log.trace(`Deleting round info for ${roundKey}`);

package/src/watchers/epoch_prune_watcher.ts

@@ -211,7 +211,10 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     }
 
     const gv = blockFromL1.header.globalVariables;
-    const { block, failedTxs, numTxs } = await checkpointBuilder.buildBlock(txs, gv.blockNumber, gv.timestamp, {});
+    const { block, failedTxs, numTxs } = await checkpointBuilder.buildBlock(txs, gv.blockNumber, gv.timestamp, {
+      isBuildingProposal: false,
+      minValidTxs: 0,
+    });
 
     if (numTxs !== txs.length) {
       // This should be detected by state mismatch, but this makes it easier to debug.

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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"}