@aztec/slasher 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/test/dummy_watcher.ts

@@ -0,0 +1,21 @@
+import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+
+import EventEmitter from 'node:events';
+
+import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
+
+export class DummyWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
+  public updateConfig(_config: Partial<SlasherConfig>) {}
+
+  public start() {
+    return Promise.resolve();
+  }
+
+  public stop() {
+    return Promise.resolve();
+  }
+
+  public triggerSlash(args: WantToSlashArgs[]) {
+    this.emit(WANT_TO_SLASH_EVENT, args);
+  }
+}

package/src/watcher.ts

@@ -2,13 +2,15 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import { OffenseType } from '@aztec/stdlib/slashing';
 
+import type { SlasherConfig } from './config.js';
+
 export const WANT_TO_SLASH_EVENT = 'want-to-slash' as const;
 
 export interface WantToSlashArgs {
   validator: EthAddress;
   amount: bigint;
   offenseType: OffenseType;
-  epochOrSlot: bigint; // Epoch number for epoch-based offenses, block number for block-based
+  epochOrSlot: bigint; // Epoch number for epoch-based offenses, slot number for slot-based
 }
 
 // Event map for specific, known events of a watcher
@@ -21,4 +23,5 @@ export type WatcherEmitter = TypedEventEmitter<WatcherEventMap>;
 export type Watcher = WatcherEmitter & {
   start?: () => Promise<void>;
   stop?: () => Promise<void>;
+  updateConfig: (config: Partial<SlasherConfig>) => void;
 };

package/src/watchers/attestations_block_watcher.ts

@@ -1,10 +1,12 @@
 import { EpochCache } from '@aztec/epoch-cache';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
   type InvalidBlockDetectedEvent,
+  type L2BlockInfo,
   type L2BlockSourceEventEmitter,
   L2BlockSourceEvents,
-  PublishedL2Block,
   type ValidateBlockNegativeResult,
 } from '@aztec/stdlib/block';
 import { OffenseType } from '@aztec/stdlib/slashing';
@@ -14,6 +16,13 @@ import EventEmitter from 'node:events';
 import type { SlasherConfig } from '../config.js';
 import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
 
+const AttestationsBlockWatcherConfigKeys = [
+  'slashAttestDescendantOfInvalidPenalty',
+  'slashProposeInvalidAttestationsPenalty',
+] as const;
+
+type AttestationsBlockWatcherConfig = Pick<SlasherConfig, (typeof AttestationsBlockWatcherConfigKeys)[number]>;
+
 /**
  * This watcher is responsible for detecting invalid blocks and creating slashing arguments for offenders.
  * An invalid block is one that doesn't have enough attestations or has incorrect attestations.
@@ -29,13 +38,14 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
   // All invalid archive roots seen
   private invalidArchiveRoots: Set<string> = new Set();
 
+  private config: AttestationsBlockWatcherConfig;
+
   private boundHandleInvalidBlock = (event: InvalidBlockDetectedEvent) => {
     try {
       this.handleInvalidBlock(event);
     } catch (err) {
       this.log.error('Error handling invalid block', err, {
-        ...event.validationResult.block.block.toBlockInfo(),
-        ...event.validationResult.block.l1,
+        ...event.validationResult,
         reason: event.validationResult.reason,
       });
     }
@@ -44,13 +54,16 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
   constructor(
     private l2BlockSource: L2BlockSourceEventEmitter,
     private epochCache: EpochCache,
-    private config: Pick<
-      SlasherConfig,
-      'slashAttestDescendantOfInvalidPenalty' | 'slashProposeInvalidAttestationsPenalty'
-    >,
+    config: AttestationsBlockWatcherConfig,
   ) {
     super();
-    this.log.info('InvalidBlockWatcher initialized');
+    this.config = pick(config, ...AttestationsBlockWatcherConfigKeys);
+    this.log.info('AttestationsBlockWatcher initialized');
+  }
+
+  public updateConfig(newConfig: Partial<AttestationsBlockWatcherConfig>) {
+    this.config = merge(this.config, pick(newConfig, ...AttestationsBlockWatcherConfigKeys));
+    this.log.verbose('AttestationsBlockWatcher config updated', this.config);
   }
 
   public start() {
@@ -68,16 +81,16 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
 
   private handleInvalidBlock(event: InvalidBlockDetectedEvent): void {
     const { validationResult } = event;
-    const block = validationResult.block.block;
+    const block = validationResult.block;
 
     // Check if we already have processed this block, archiver may emit the same event multiple times
-    if (this.invalidArchiveRoots.has(block.archive.root.toString())) {
-      this.log.trace(`Already processed invalid block ${block.number}`);
+    if (this.invalidArchiveRoots.has(block.archive.toString())) {
+      this.log.trace(`Already processed invalid block ${block.blockNumber}`);
       return;
     }
 
-    this.log.verbose(`Detected invalid block ${block.number}`, {
-      ...block.toBlockInfo(),
+    this.log.verbose(`Detected invalid block ${block.blockNumber}`, {
+      ...block,
       reason: validationResult.valid === false ? validationResult.reason : 'unknown',
     });
 
@@ -94,11 +107,11 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
   private slashAttestorsOnAncestorInvalid(validationResult: ValidateBlockNegativeResult) {
     const block = validationResult.block;
 
-    const parentArchive = block.block.header.lastArchive.root.toString();
-    if (this.invalidArchiveRoots.has(block.block.header.lastArchive.root.toString())) {
-      const attestors = validationResult.attestations.map(a => a.getSender());
-      this.log.info(`Want to slash attestors of block ${block.block.number} built on invalid block`, {
-        ...block.block.toBlockInfo(),
+    const parentArchive = block.lastArchive.toString();
+    if (this.invalidArchiveRoots.has(parentArchive)) {
+      const attestors = validationResult.attestors;
+      this.log.info(`Want to slash attestors of block ${block.blockNumber} built on invalid block`, {
+        ...block,
         ...attestors,
         parentArchive,
       });
@@ -109,7 +122,7 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
           validator: attestor,
           amount: this.config.slashAttestDescendantOfInvalidPenalty,
           offenseType: OffenseType.ATTESTED_DESCENDANT_OF_INVALID,
-          epochOrSlot: block.block.slot,
+          epochOrSlot: BigInt(SlotNumber(block.slotNumber)),
         })),
       );
     }
@@ -117,9 +130,14 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
 
   private slashProposer(validationResult: ValidateBlockNegativeResult) {
     const { reason, block } = validationResult;
-    const blockNumber = block.block.number;
-    const slot = block.block.header.getSlot();
-    const proposer = this.epochCache.getProposerFromEpochCommittee(validationResult, slot);
+    const blockNumber = block.blockNumber;
+    const slot = block.slotNumber;
+    const epochCommitteeInfo = {
+      committee: validationResult.committee,
+      seed: validationResult.seed,
+      epoch: validationResult.epoch,
+    };
+    const proposer = this.epochCache.getProposerFromEpochCommittee(epochCommitteeInfo, slot);
 
     if (!proposer) {
       this.log.warn(`No proposer found for block ${blockNumber} at slot ${slot}`);
@@ -132,11 +150,11 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
       validator: proposer,
       amount,
       offenseType: offense,
-      epochOrSlot: block.block.slot,
+      epochOrSlot: BigInt(slot),
     };
 
     this.log.info(`Want to slash proposer of block ${blockNumber} due to ${reason}`, {
-      ...block.block.toBlockInfo(),
+      ...block,
       ...args,
     });
 
@@ -156,8 +174,8 @@ export class AttestationsBlockWatcher extends (EventEmitter as new () => Watcher
     }
   }
 
-  private addInvalidBlock(block: PublishedL2Block) {
-    this.invalidArchiveRoots.add(block.block.archive.root.toString());
+  private addInvalidBlock(block: L2BlockInfo) {
+    this.invalidArchiveRoots.add(block.archive.toString());
 
     // Prune old entries if we exceed the maximum
     if (this.invalidArchiveRoots.size > this.maxInvalidBlocks) {

package/src/watchers/epoch_prune_watcher.ts

@@ -1,5 +1,6 @@
-import type { Tx } from '@aztec/aztec.js';
 import { EpochCache } from '@aztec/epoch-cache';
+import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
   EthAddress,
@@ -8,9 +9,15 @@ import {
   type L2BlockSourceEventEmitter,
   L2BlockSourceEvents,
 } from '@aztec/stdlib/block';
-import type { IFullNodeBlockBuilder, ITxProvider, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import type {
+  IFullNodeBlockBuilder,
+  ITxProvider,
+  MerkleTreeWriteOperations,
+  SlasherConfig,
+} from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import { OffenseType } from '@aztec/stdlib/slashing';
+import { OffenseType, getOffenseTypeName } from '@aztec/stdlib/slashing';
 import {
   ReExFailedTxsError,
   ReExStateMismatchError,
@@ -22,10 +29,9 @@ import EventEmitter from 'node:events';
 
 import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from '../watcher.js';
 
-type EpochPruneWatcherPenalties = {
-  slashPrunePenalty: bigint;
-  slashDataWithholdingPenalty: bigint;
-};
+const EpochPruneWatcherPenaltiesConfigKeys = ['slashPrunePenalty', 'slashDataWithholdingPenalty'] as const;
+
+type EpochPruneWatcherPenalties = Pick<SlasherConfig, (typeof EpochPruneWatcherPenaltiesConfigKeys)[number]>;
 
 /**
  * This watcher is responsible for detecting chain prunes and creating slashing arguments for the committee.
@@ -39,15 +45,18 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   // Store bound function reference for proper listener removal
   private boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
 
+  private penalties: EpochPruneWatcherPenalties;
+
   constructor(
     private l2BlockSource: L2BlockSourceEventEmitter,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private epochCache: EpochCache,
     private txProvider: Pick<ITxProvider, 'getAvailableTxs'>,
     private blockBuilder: IFullNodeBlockBuilder,
-    private penalties: EpochPruneWatcherPenalties,
+    penalties: EpochPruneWatcherPenalties,
   ) {
     super();
+    this.penalties = pick(penalties, ...EpochPruneWatcherPenaltiesConfigKeys);
     this.log.verbose(
       `EpochPruneWatcher initialized with penalties: valid epoch pruned=${penalties.slashPrunePenalty} data withholding=${penalties.slashDataWithholdingPenalty}`,
     );
@@ -63,56 +72,58 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     return Promise.resolve();
   }
 
+  public updateConfig(config: Partial<SlasherConfig>): void {
+    this.penalties = merge(this.penalties, pick(config, ...EpochPruneWatcherPenaltiesConfigKeys));
+    this.log.verbose('EpochPruneWatcher config updated', this.penalties);
+  }
+
   private handlePruneL2Blocks(event: L2BlockPruneEvent): void {
     const { blocks, epochNumber } = event;
-    this.log.info(`Detected chain prune. Validating epoch ${epochNumber}`);
-
-    this.validateBlocks(blocks)
-      .then(async () => {
-        this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
-        const validators = await this.getValidatorsForEpoch(epochNumber);
-        // need to specify return type to be able to return offense as undefined later on
-        const result: { validators: EthAddress[]; offense: OffenseType | undefined } = {
-          validators,
-          offense: OffenseType.VALID_EPOCH_PRUNED,
-        };
-        return result;
-      })
-      .catch(async error => {
-        if (error instanceof TransactionsNotAvailableError) {
-          this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, error);
-          const validators = await this.getValidatorsForEpoch(epochNumber);
-          return {
-            validators,
-            offense: OffenseType.DATA_WITHHOLDING,
-          };
-        } else {
-          this.log.error(`Error while validating pruned epoch ${epochNumber}. Will not want to slash.`, error);
-          return {
-            validators: [],
-            offense: undefined,
-          };
-        }
-      })
-      .then(({ validators, offense }) => {
-        if (validators.length === 0 || offense === undefined) {
-          return;
-        }
-        const args = this.validatorsToSlashingArgs(validators, offense, BigInt(epochNumber));
-        this.log.info(`Slash for epoch ${epochNumber} created`, args);
-        this.emit(WANT_TO_SLASH_EVENT, args);
-      })
-      .catch(error => {
-        // This can happen if we fail to get the validators for the epoch.
-        this.log.error('Error while creating slash for epoch', error);
-      });
+    void this.processPruneL2Blocks(blocks, epochNumber).catch(err =>
+      this.log.error('Error processing pruned L2 blocks', err, { epochNumber }),
+    );
+  }
+
+  private async emitSlashForEpoch(offense: OffenseType, epochNumber: EpochNumber): Promise<void> {
+    const validators = await this.getValidatorsForEpoch(epochNumber);
+    if (validators.length === 0) {
+      this.log.warn(`No validators found for epoch ${epochNumber} (cannot slash for ${getOffenseTypeName(offense)})`);
+      return;
+    }
+    const args = this.validatorsToSlashingArgs(validators, offense, epochNumber);
+    this.log.verbose(`Created slash for ${getOffenseTypeName(offense)} at epoch ${epochNumber}`, args);
+    this.emit(WANT_TO_SLASH_EVENT, args);
+  }
+
+  private async processPruneL2Blocks(blocks: L2Block[], epochNumber: EpochNumber): Promise<void> {
+    try {
+      const l1Constants = this.epochCache.getL1Constants();
+      const epochBlocks = blocks.filter(b => getEpochAtSlot(b.slot, l1Constants) === epochNumber);
+      this.log.info(
+        `Detected chain prune. Validating epoch ${epochNumber} with blocks ${epochBlocks[0]?.number} to ${epochBlocks[epochBlocks.length - 1]?.number}.`,
+        { blocks: epochBlocks.map(b => b.toBlockInfo()) },
+      );
+
+      await this.validateBlocks(epochBlocks);
+      this.log.info(`Pruned epoch ${epochNumber} was valid. Want to slash committee for not having it proven.`);
+      await this.emitSlashForEpoch(OffenseType.VALID_EPOCH_PRUNED, epochNumber);
+    } catch (error) {
+      if (error instanceof TransactionsNotAvailableError) {
+        this.log.info(`Data for pruned epoch ${epochNumber} was not available. Will want to slash.`, {
+          message: error.message,
+        });
+        await this.emitSlashForEpoch(OffenseType.DATA_WITHHOLDING, epochNumber);
+      } else {
+        this.log.error(`Error while validating pruned epoch ${epochNumber}. Will not want to slash.`, error);
+      }
+    }
   }
 
   public async validateBlocks(blocks: L2Block[]): Promise<void> {
     if (blocks.length === 0) {
       return;
     }
-    const fork = await this.blockBuilder.getFork(blocks[0].header.globalVariables.blockNumber - 1);
+    const fork = await this.blockBuilder.getFork(BlockNumber(blocks[0].header.globalVariables.blockNumber - 1));
     try {
       for (const block of blocks) {
         await this.validateBlock(block, fork);
@@ -134,9 +145,10 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
       throw new TransactionsNotAvailableError(missingTxs);
     }
 
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockFromL1.number);
+    const checkpointNumber = CheckpointNumber.fromBlockNumber(blockFromL1.number);
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
     const { block, failedTxs, numTxs } = await this.blockBuilder.buildBlock(
-      txs as Tx[],
+      txs,
       l1ToL2Messages,
       blockFromL1.header.globalVariables,
       {},
@@ -154,7 +166,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
     }
   }
 
-  private async getValidatorsForEpoch(epochNumber: bigint): Promise<EthAddress[]> {
+  private async getValidatorsForEpoch(epochNumber: EpochNumber): Promise<EthAddress[]> {
     const { committee } = await this.epochCache.getCommitteeForEpoch(epochNumber);
     if (!committee) {
       this.log.trace(`No committee found for epoch ${epochNumber}`);
@@ -166,7 +178,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   private validatorsToSlashingArgs(
     validators: EthAddress[],
     offenseType: OffenseType,
-    epochOrSlot: bigint,
+    epochOrSlot: EpochNumber,
   ): WantToSlashArgs[] {
     const penalty =
       offenseType === OffenseType.DATA_WITHHOLDING
@@ -176,7 +188,7 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
       validator: v,
       amount: penalty,
       offenseType,
-      epochOrSlot,
+      epochOrSlot: BigInt(epochOrSlot),
     }));
   }
 }