@aztec/slasher 2.1.0-rc.9 → 3.0.0-devnet.2

package/README.md

@@ -24,11 +24,11 @@ The system supports two slashing models:
 
 _This is the model currently in use._
 
-The tally model uses consensus-based voting where proposers vote on individual validator offenses. Time is divided into rounds, and during each round, proposers submit votes indicating which validators should be slashed. Votes are encoded as bytes where each validator's vote is represented by 2 bits indicating the slash amount (0-3 slash units) for each validator. The L1 contract tallies votes and slashes validators that reach quorum.
+The tally model uses consensus-based voting where proposers vote on individual validator offenses. Time is divided into rounds, and during each round, proposers submit votes indicating which validators from a given past round should be slashed (eg round N votes to slash the validators from round N-2). Votes are encoded as bytes where each validator's vote is represented by 2 bits indicating the slash amount (0-3 slash units) for each validator. The L1 contract tallies votes and slashes validators that reach quorum.
 
 Key characteristics:
 - Proposers vote directly on validator offenses
-- Uses a slash offset to vote on validators from past rounds (e.g., round N votes on round N-2)
+- Requires a slash offset to vote on validators from past rounds
 - Requires quorum to execute slashing
 - L1 contract determines which offenses reach consensus
 - Execution happens after a delay period for review
@@ -98,6 +98,8 @@ Key features:
 
 ## Slashable Offenses
 
+List of all slashable offenses in the system:
+
 ### DATA_WITHHOLDING
 **Description**: The data required for proving an epoch was not made publicly available.  
 **Detection**: EpochPruneWatcher detects when an epoch cannot be proven due to missing data.  
@@ -121,7 +123,6 @@ Key features:
 **Detection**: Validators detect invalid proposals during attestation validation.  
 **Target**: Proposer who broadcast the invalid block.  
 **Time Unit**: Slot-based offense.  
-**Note**: Currently not actively monitored in production.
 
 ### PROPOSED_INSUFFICIENT_ATTESTATIONS
 **Description**: A proposer submitted a block to L1 without sufficient committee attestations.  
@@ -146,24 +147,72 @@ Key features:
 ### L1 System Settings (L1ContractsConfig)
 These settings are deployed with the L1 contracts and apply system-wide to the protocol:
 
-- `slashingRoundSize`: Number of slots per slashing round (default: 192, must be multiple of epochs)
-- `slashingQuorumSize`: Votes required to slash (tally model)
+- `slashingQuorumSize`: Votes required to slash (defaults to half the validators in a round, plus one)
+- `slashingRoundSizeInEpochs`: Number of epochs per slashing round
 - `slashingOffsetInRounds`: How many rounds to look back for offenses (tally model)
 - `slashingExecutionDelayInRounds`: Rounds to wait before execution
 - `slashingLifetimeInRounds`: Maximum age of executable rounds
 - `slashingAmounts`: Valid values for each individual slash (tally model)
 
+Considerations:
+
+- The `slashingQuorumSize` should be more than half and less than the total number of validators in a round, so that we require a majority to slash. The number of validators in a round is the committee size times the number of epochs in a round.
+- The bigger a `slashingRoundSizeInEpochs`, the bigger the upper bound on the quorum size. This increases security, as we need more validators to agree before slashing. However, it also makes slashing slower, and more expensive to execute in terms of gas in the tally model.
+- The `slashingOffsetInRounds` is required because the validators in a given slashing round must vote for _past_ offenses. Otherwise, if someone commits an offense near the end of a round, they can get away with their offense without the validators being able to collect enough votes to slash them. The offset needs to be big enough so that all offenses are discoverable, so this value should be strictly greater than the proof submission window in order to be able to slash for epoch prunes or data withholding.
+- The `slashingExecutionDelayInRounds` allows vetoers to stop an invalid slash. This should be large enough to give vetoers time to act, but strictly smaller than the validator exit window, so an offender cannot escape before they are slashed. It should also be small enough so that an offender that would be kicked out does not get picked up to be a committee member again before their slash is executed. In other words, if a validator commits a serious enough offense that we want them out of the validator set as soon as possible, the execution delay should not allow them to be chosen to participate in another committee.
+
 ### Local Node Configuration (SlasherConfig)
+
 These settings are configured locally on each validator node:
 
 - `slashGracePeriodL2Slots`: Number of initial L2 slots where slashing is disabled
-- `slashMaxPayloadSize`: Maximum size of slash payloads (empire model)
 - `slashOffenseExpirationRounds`: Number of rounds after which pending offenses expire
 - `slashValidatorsAlways`: Array of validator addresses that should always be slashed
 - `slashValidatorsNever`: Array of validator addresses that should never be slashed (own validator addresses are automatically added to this list)
-- `slashPrunePenalty`: Penalty for DATA_WITHHOLDING and VALID_EPOCH_PRUNED offenses
-- `slashInactivityPenalty`: Penalty for INACTIVITY offenses
-- `slashBroadcastedInvalidBlockPenalty`: Penalty for broadcasting invalid blocks
-- `slashProposeInvalidAttestationsPenalty`: Penalty for proposing with insufficient/incorrect attestations
-- `slashAttestDescendantOfInvalidPenalty`: Penalty for attesting to descendants of invalid blocks
+- `slashInactivityTargetPercentage`: Percentage of misses during an epoch to be slashed for INACTIVITY
+- `slashInactivityConsecutiveEpochThreshold`: How many consecutive inactive epochs are needed to trigger an INACTIVITY slash on a validator
+- `slashPrunePenalty`: Penalty for VALID_EPOCH_PRUNED
+- `slashDataWithholdingPenalty`: Penalty for DATA_WITHHOLDING
+- `slashInactivityPenalty`: Penalty for INACTIVITY
+- `slashBroadcastedInvalidBlockPenalty`: Penalty for BROADCASTED_INVALID_BLOCK_PROPOSAL
+- `slashProposeInvalidAttestationsPenalty`: Penalty for PROPOSED_INSUFFICIENT_ATTESTATIONS and PROPOSED_INCORRECT_ATTESTATIONS
+- `slashAttestDescendantOfInvalidPenalty`: Penalty for ATTESTED_DESCENDANT_OF_INVALID
 - `slashUnknownPenalty`: Default penalty for unknown offense types
+- `slashMaxPayloadSize`: Maximum size of slash payloads (empire model)
+- `slashMinPenaltyPercentage`: Agree to slashes if they are at least this percentage of the configured penalty (empire model)
+- `slashMaxPenaltyPercentage`: Agree to slashes if they are at most this percentage of the configured penalty (empire model)
+
+Considerations:
+
+- All penalties should map to one of the `slashingAmounts`. A penalty lower than the smallest slashing amount will not be executable, and a penalty greater than the maximum will be capped at the maximum value.
+- The `slashOffenseExpirationRounds` should be strictly larger than the `slashingOffsetInRounds`. This can be a relatively large value, as it's used only for data store cleanup.
+
+## Offenses In-Depth
+
+Details about specific offenses in the system:
+
+### Inactivity
+
+Inactivity slashing is one of the most critical, since it allows purging validators that are not fulfilling their duties, which could potentially bring the chain to a halt. This slashing must be aggressive enough to balance out the rate of the entry queue, in case the queue is filled with inactive validators. Furthermore, if enough inactive validators join the system, it may become impossible to gather enough quorum to pass any governance proposal.
+
+Inactivity slashing is handled by the `Sentinel` which monitors performance of all validators slot-by-slot. After each slot, the sentinel assigns one of the following to the block proposer for the slot:
+- `block-mined` if the block was added to L1
+- `block-proposed` if the block received at least one attestation, but didn't make it to L1
+- `block-missed` if the block received no attestations (note that we cannot rely on the P2P proposal alone since it may be invalid, unless we reexecute it)
+
+And assigns one of the following to each validator:
+- `attestation-sent` if there was a `block-proposed` or `block-mined` and an attestation from this validator was seen on either on L1 or on the P2P network
+- `attestation-missed` if there was a `block-proposed` or `block-mined` but no attestation was seen
+- none if the slot was a `block-missed`
+
+Once an epoch is proven, the sentinel computes the _proven performance_ for the epoch for each validator. Note that we wait until the epoch is proven so we know that the data for all blocks in the epoch was available, and validators who did not attest were effectively inactive. Then, for each validator such that:
+
+```
+total_failures = count(block-missed) + count(attestation-missed)
+total = count(block-*) + count(attestation-*)
+total_failures / total >= slash_inactivity_target_percentage
+```
+
+They are voted to be slashed for inactivity. Note that, if `slashInactivityConsecutiveEpochThreshold` is greater than one, we first check if the above is true for the last `threshold` times the given validator was part of a committee, and only then trigger the offense.
+
+

package/dest/stores/offenses_store.js

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
 import { deserializeOffense, getRoundForOffense, serializeOffense } from '@aztec/stdlib/slashing';
 export const SCHEMA_VERSION = 1;
 export class SlasherOffensesStore {

package/dest/tally_slasher_client.d.ts

@@ -67,7 +67,7 @@ export declare class TallySlasherClient implements ProposerSlashActionProvider,
     protected unwatchCallbacks: (() => void)[];
     protected roundMonitor: SlashRoundMonitor;
     protected offensesCollector: SlashOffensesCollector;
-    constructor(config: TallySlasherClientConfig, settings: TallySlasherSettings, tallySlashingProposer: TallySlashingProposerContract, slasher: SlasherContract, rollup: RollupContract, watchers: Watcher[], epochCache: EpochCache, dateProvider: DateProvider, offensesStore: SlasherOffensesStore, log?: import("@aztec/aztec.js").Logger);
+    constructor(config: TallySlasherClientConfig, settings: TallySlasherSettings, tallySlashingProposer: TallySlashingProposerContract, slasher: SlasherContract, rollup: RollupContract, watchers: Watcher[], epochCache: EpochCache, dateProvider: DateProvider, offensesStore: SlasherOffensesStore, log?: import("@aztec/foundation/log").Logger);
     start(): Promise<void>;
     /**
      * Stop the tally slasher client
@@ -95,6 +95,7 @@ export declare class TallySlasherClient implements ProposerSlashActionProvider,
     /**
      * Checks if a given round is executable and returns an execute-slash action for it if so.
      * Assumes round number has already been checked against lifetime and execution delay.
+     * @param executableRound - The round to check for execution
      */
     private tryGetRoundExecuteAction;
     /** Returns a vote action based on offenses from the target round (with offset applied) */

package/dest/tally_slasher_client.d.ts.map

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

package/dest/tally_slasher_client.js

@@ -1,4 +1,4 @@
-import { EthAddress } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { compactArray, partition, times } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
@@ -129,7 +129,13 @@ import { SlashRoundMonitor } from './slash_round_monitor.js';
         const slashingExecutionDelayInRounds = BigInt(this.settings.slashingExecutionDelayInRounds);
         const executableRound = currentRound - slashingExecutionDelayInRounds - 1n;
         const lookBack = BigInt(this.config.slashExecuteRoundsLookBack);
-        const oldestExecutableRound = maxBigint(0n, executableRound - lookBack);
+        const slashingLifetimeInRounds = BigInt(this.settings.slashingLifetimeInRounds);
+        // Compute the oldest executable round considering both lookBack and lifetimeInRounds
+        // A round is only executable if currentRound <= round + lifetimeInRounds
+        // So the oldest round we can execute is: currentRound - lifetimeInRounds
+        const oldestByLifetime = maxBigint(0n, currentRound - slashingLifetimeInRounds);
+        const oldestByLookBack = maxBigint(0n, executableRound - lookBack);
+        const oldestExecutableRound = maxBigint(oldestByLifetime, oldestByLookBack);
         // Check if slashing is enabled at all
         if (!await this.slasher.isSlashingEnabled()) {
             this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`);
@@ -139,14 +145,16 @@ import { SlashRoundMonitor } from './slash_round_monitor.js';
             slotNumber,
             currentRound,
             oldestExecutableRound,
+            oldestByLifetime,
+            oldestByLookBack,
             executableRound,
             slashingExecutionDelayInRounds,
             lookBack,
-            slashingLifetimeInRounds: this.settings.slashingLifetimeInRounds
+            slashingLifetimeInRounds
         });
         // Iterate over all rounds, starting from the oldest, until we find one that is executable
         for(let roundToCheck = oldestExecutableRound; roundToCheck <= executableRound; roundToCheck++){
-            const action = await this.tryGetRoundExecuteAction(roundToCheck);
+            const action = await this.tryGetRoundExecuteAction(roundToCheck, slotNumber);
             if (action) {
                 return action;
             }
@@ -157,17 +165,14 @@ import { SlashRoundMonitor } from './slash_round_monitor.js';
     /**
    * Checks if a given round is executable and returns an execute-slash action for it if so.
    * Assumes round number has already been checked against lifetime and execution delay.
-   */ async tryGetRoundExecuteAction(executableRound) {
+   * @param executableRound - The round to check for execution
+   */ async tryGetRoundExecuteAction(executableRound, slotNumber) {
         let logData = {
-            executableRound
+            executableRound,
+            slotNumber
         };
         this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
         try {
-            // Check if slashing is enabled at all
-            if (!await this.slasher.isSlashingEnabled()) {
-                this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`, logData);
-                return undefined;
-            }
             const roundInfo = await this.tallySlashingProposer.getRound(executableRound);
             logData = {
                 ...logData,
@@ -183,6 +188,12 @@ import { SlashRoundMonitor } from './slash_round_monitor.js';
                 this.log.verbose(`Round ${executableRound} does not have enough votes to execute`, logData);
                 return undefined;
             }
+            // Check if round is ready to execute at the given slot
+            const isReadyToExecute = await this.tallySlashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
+            if (!isReadyToExecute) {
+                this.log.warn(`Round ${executableRound} is not ready to execute at slot ${slotNumber} according to contract check`, logData);
+                return undefined;
+            }
             // Check if the round yields any slashing at all
             const { actions: slashActions, committees } = await this.tallySlashingProposer.getTally(executableRound);
             if (slashActions.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/slasher",
-  "version": "2.1.0-rc.9",
+  "version": "3.0.0-devnet.2",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -54,20 +54,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/epoch-cache": "2.1.0-rc.9",
-    "@aztec/ethereum": "2.1.0-rc.9",
-    "@aztec/foundation": "2.1.0-rc.9",
-    "@aztec/kv-store": "2.1.0-rc.9",
-    "@aztec/l1-artifacts": "2.1.0-rc.9",
-    "@aztec/stdlib": "2.1.0-rc.9",
-    "@aztec/telemetry-client": "2.1.0-rc.9",
+    "@aztec/epoch-cache": "3.0.0-devnet.2",
+    "@aztec/ethereum": "3.0.0-devnet.2",
+    "@aztec/foundation": "3.0.0-devnet.2",
+    "@aztec/kv-store": "3.0.0-devnet.2",
+    "@aztec/l1-artifacts": "3.0.0-devnet.2",
+    "@aztec/stdlib": "3.0.0-devnet.2",
+    "@aztec/telemetry-client": "3.0.0-devnet.2",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
-    "viem": "2.23.7",
+    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@aztec/aztec.js": "2.1.0-rc.9",
+    "@aztec/aztec.js": "3.0.0-devnet.2",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/stores/offenses_store.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSet } from '@aztec/kv-store';
 import {
   type Offense,

package/src/tally_slasher_client.ts

@@ -1,4 +1,4 @@
-import { EthAddress } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import type { EpochCache } from '@aztec/epoch-cache';
 import { RollupContract, SlasherContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
 import { maxBigint } from '@aztec/foundation/bigint';
@@ -187,7 +187,14 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
     const slashingExecutionDelayInRounds = BigInt(this.settings.slashingExecutionDelayInRounds);
     const executableRound = currentRound - slashingExecutionDelayInRounds - 1n;
     const lookBack = BigInt(this.config.slashExecuteRoundsLookBack);
-    const oldestExecutableRound = maxBigint(0n, executableRound - lookBack);
+    const slashingLifetimeInRounds = BigInt(this.settings.slashingLifetimeInRounds);
+
+    // Compute the oldest executable round considering both lookBack and lifetimeInRounds
+    // A round is only executable if currentRound <= round + lifetimeInRounds
+    // So the oldest round we can execute is: currentRound - lifetimeInRounds
+    const oldestByLifetime = maxBigint(0n, currentRound - slashingLifetimeInRounds);
+    const oldestByLookBack = maxBigint(0n, executableRound - lookBack);
+    const oldestExecutableRound = maxBigint(oldestByLifetime, oldestByLookBack);
 
     // Check if slashing is enabled at all
     if (!(await this.slasher.isSlashingEnabled())) {
@@ -199,15 +206,17 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
       slotNumber,
       currentRound,
       oldestExecutableRound,
+      oldestByLifetime,
+      oldestByLookBack,
       executableRound,
       slashingExecutionDelayInRounds,
       lookBack,
-      slashingLifetimeInRounds: this.settings.slashingLifetimeInRounds,
+      slashingLifetimeInRounds,
     });
 
     // Iterate over all rounds, starting from the oldest, until we find one that is executable
     for (let roundToCheck = oldestExecutableRound; roundToCheck <= executableRound; roundToCheck++) {
-      const action = await this.tryGetRoundExecuteAction(roundToCheck);
+      const action = await this.tryGetRoundExecuteAction(roundToCheck, slotNumber);
       if (action) {
         return action;
       }
@@ -220,18 +229,16 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
   /**
    * Checks if a given round is executable and returns an execute-slash action for it if so.
    * Assumes round number has already been checked against lifetime and execution delay.
+   * @param executableRound - The round to check for execution
    */
-  private async tryGetRoundExecuteAction(executableRound: bigint): Promise<ProposerSlashAction | undefined> {
-    let logData: Record<string, unknown> = { executableRound };
+  private async tryGetRoundExecuteAction(
+    executableRound: bigint,
+    slotNumber: bigint,
+  ): Promise<ProposerSlashAction | undefined> {
+    let logData: Record<string, unknown> = { executableRound, slotNumber };
     this.log.debug(`Testing if slashing round ${executableRound} is executable`, logData);
 
     try {
-      // Check if slashing is enabled at all
-      if (!(await this.slasher.isSlashingEnabled())) {
-        this.log.warn(`Slashing is disabled in the Slasher contract (skipping execution)`, logData);
-        return undefined;
-      }
-
       const roundInfo = await this.tallySlashingProposer.getRound(executableRound);
       logData = { ...logData, roundInfo };
       if (roundInfo.isExecuted) {
@@ -245,6 +252,16 @@ export class TallySlasherClient implements ProposerSlashActionProvider, SlasherC
         return undefined;
       }
 
+      // Check if round is ready to execute at the given slot
+      const isReadyToExecute = await this.tallySlashingProposer.isRoundReadyToExecute(executableRound, slotNumber);
+      if (!isReadyToExecute) {
+        this.log.warn(
+          `Round ${executableRound} is not ready to execute at slot ${slotNumber} according to contract check`,
+          logData,
+        );
+        return undefined;
+      }
+
       // Check if the round yields any slashing at all
       const { actions: slashActions, committees } = await this.tallySlashingProposer.getTally(executableRound);
       if (slashActions.length === 0) {