@aztec/slasher 1.2.1 → 2.0.0-nightly.20250814

package/dest/slasher_client.js

@@ -3,8 +3,9 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { SlashFactoryAbi } from '@aztec/l1-artifacts';
+import { bigIntToOffense } from '@aztec/stdlib/slashing';
 import { encodeFunctionData, getAddress, getContract } from 'viem';
-import { WANT_TO_SLASH_EVENT, bigIntToOffense } from './config.js';
+import { WANT_TO_SLASH_EVENT } from './config.js';
 /**
  * A Spartiate slasher client implementation
  *
@@ -39,21 +40,27 @@ import { WANT_TO_SLASH_EVENT, bigIntToOffense } from './config.js';
     monitoredPayloads;
     unwatchCallbacks;
     overridePayloadActive;
-    static async new(config, l1Contracts, l1TxUtils, watchers, dateProvider) {
+    slashingExecutionDelayInRounds;
+    static async new(config, l1Contracts, l1TxUtils, l1Client, watchers, dateProvider) {
         if (!l1Contracts.rollupAddress) {
             throw new Error('Cannot initialize SlasherClient without a rollup address');
         }
         if (!l1Contracts.slashFactoryAddress) {
             throw new Error('Cannot initialize SlasherClient without a slashFactory address');
         }
-        const rollup = new RollupContract(l1TxUtils.client, l1Contracts.rollupAddress);
+        const rollup = new RollupContract(l1Client, l1Contracts.rollupAddress);
         const slashingProposer = await rollup.getSlashingProposer();
         const slashFactoryContract = getContract({
             address: getAddress(l1Contracts.slashFactoryAddress.toString()),
             abi: SlashFactoryAbi,
-            client: l1TxUtils.client
+            client: l1Client
         });
-        return new SlasherClient(config, slashFactoryContract, slashingProposer, l1TxUtils, watchers, dateProvider);
+        const slasherClient = new SlasherClient(config, slashFactoryContract, slashingProposer, l1TxUtils, watchers, dateProvider);
+        rollup.listenToSlasherChanged(async ()=>{
+            const newSlashingProposer = await rollup.getSlashingProposer();
+            await slasherClient.setSlashingProposer(newSlashingProposer);
+        });
+        return slasherClient;
     }
     constructor(config, slashFactoryContract, slashingProposer, l1TxUtils, watchers, dateProvider, log = createLogger('slasher')){
         this.config = config;
@@ -66,23 +73,26 @@ import { WANT_TO_SLASH_EVENT, bigIntToOffense } from './config.js';
         this.monitoredPayloads = [];
         this.unwatchCallbacks = [];
         this.overridePayloadActive = false;
+        this.slashingExecutionDelayInRounds = 0n;
         this.overridePayloadActive = config.slashOverridePayload !== undefined && !config.slashOverridePayload.isZero();
     }
     //////////////////// Public methods ////////////////////
-    start() {
-        this.log.info('Starting Slasher client...');
+    async start() {
+        this.log.debug('Starting Slasher client...');
+        this.slashingExecutionDelayInRounds = await this.slashingProposer.getExecutionDelayInRounds();
         // detect when new payloads are created
         this.unwatchCallbacks.push(this.watchSlashFactoryEvents());
-        // detect when a proposal is executable
-        this.unwatchCallbacks.push(this.slashingProposer.listenToExecutableProposals(this.executeRoundIfAgree.bind(this)));
-        // detect when a proposal is executed
-        this.unwatchCallbacks.push(this.slashingProposer.listenToProposalExecuted(this.proposalExecuted.bind(this)));
+        // detect when a payload is submittable
+        this.unwatchCallbacks.push(this.slashingProposer.listenToSubmittablePayloads(this.submitRoundIfAgree.bind(this)));
+        // detect when a payload is submitted
+        this.unwatchCallbacks.push(this.slashingProposer.listenToPayloadSubmitted(this.payloadSubmitted.bind(this)));
         // start each watcher, who will signal the slasher client when they want to slash
         const wantToSlashCb = this.wantToSlash.bind(this);
         for (const watcher of this.watchers){
             watcher.on(WANT_TO_SLASH_EVENT, wantToSlashCb);
             this.unwatchCallbacks.push(()=>watcher.removeListener(WANT_TO_SLASH_EVENT, wantToSlashCb));
         }
+        this.log.info(`Started Slasher client${this.l1TxUtils ? ` with publisher address ${this.l1TxUtils.client.account.address}` : ''}`);
     }
     /**
    * Allows consumers to stop the instance of the slasher client.
@@ -105,14 +115,23 @@ import { WANT_TO_SLASH_EVENT, bigIntToOffense } from './config.js';
         this.log.warn('Clearing monitored payloads', this.monitoredPayloads);
         this.monitoredPayloads = [];
     }
+    async setSlashingProposer(slashingProposer) {
+        this.log.info('Slashing proposer changed');
+        // remove the old listeners
+        await this.stop();
+        this.slashingProposer = slashingProposer;
+        // start the new listeners
+        await this.start();
+    }
     /**
    * Update the config of the slasher client
    *
-   * @param config - the new config.
+   * @param config - the new config. Cannot update the slasher private key.
    */ updateConfig(config) {
+        const { slasherPrivateKey: _doNotUpdate, ...configWithoutPrivateKey } = config;
         const newConfig = {
             ...this.config,
-            ...config
+            ...configWithoutPrivateKey
         };
         // We keep this separate flag to tell us if we should be signal for the override payload: after the override payload is executed,
         // the slasher goes back to using the monitored payloads to inform the sequencer publisher what payload to signal for.
@@ -158,17 +177,17 @@ import { WANT_TO_SLASH_EVENT, bigIntToOffense } from './config.js';
    * Bound to the slashing proposer contract's listenToProposalExecuted method in `.start()`.
    *
    * @param {round: bigint; proposal: `0x${string}`} param0
-   */ proposalExecuted({ round, proposal }) {
-        this.log.info('Proposal executed', {
+   */ payloadSubmitted({ round, payload }) {
+        this.log.info('Payload submitted', {
             round,
-            proposal
+            payload
         });
-        const payload = EthAddress.fromString(proposal);
+        const payloadAddress = EthAddress.fromString(payload);
         // Stop signaling for the override payload if it was executed
-        if (this.overridePayloadActive && this.config.slashOverridePayload?.equals(payload)) {
+        if (this.overridePayloadActive && this.config.slashOverridePayload?.equals(payloadAddress)) {
             this.overridePayloadActive = false;
         }
-        const index = this.monitoredPayloads.findIndex((p)=>p.payloadAddress.equals(payload));
+        const index = this.monitoredPayloads.findIndex((p)=>p.payloadAddress.equals(payloadAddress));
         if (index === -1) {
             return;
         }
@@ -180,6 +199,13 @@ import { WANT_TO_SLASH_EVENT, bigIntToOffense } from './config.js';
    *
    * @param args - the arguments from the watcher, including the validators, amounts, and offenses
    */ wantToSlash(args) {
+        if (!this.l1TxUtils) {
+            this.log.warn('Cannot slash validators: no slasher private key configured. Set SLASHER_PRIVATE_KEY environment variable.', {
+                validators: args.map((arg)=>arg.validator.toString()),
+                offenses: args.map((arg)=>arg.offense)
+            });
+            return;
+        }
         const sortedArgs = [
             ...args
         ].sort((a, b)=>a.validator.toString().localeCompare(b.validator.toString()));
@@ -351,32 +377,39 @@ import { WANT_TO_SLASH_EVENT, bigIntToOffense } from './config.js';
         });
     }
     /**
-   * Execute a round if we agree with the proposal.
+   * Submit a round to the Slasher if we agree with the payload.
    *
-   * Bound to the slashing proposer contract's listenToExecutableProposals method in the constructor.
+   * Bound to the slashing proposer contract's listenToSubmittablePayloads method in the constructor.
    *
    * @param {proposal: `0x${string}`; round: bigint} param0
-   */ async executeRoundIfAgree({ proposal, round }) {
-        const payload = EthAddress.fromString(proposal);
-        if (!this.monitoredPayloads.find((p)=>p.payloadAddress.equals(payload))) {
+   */ async submitRoundIfAgree({ payload, round }) {
+        if (!this.l1TxUtils) {
+            this.log.warn('Cannot execute slashing proposal: no slasher private key configured. Set SLASHER_PRIVATE_KEY environment variable.', {
+                payload,
+                round
+            });
+            return;
+        }
+        const payloadAddress = EthAddress.fromString(payload);
+        if (!this.monitoredPayloads.find((p)=>p.payloadAddress.equals(payloadAddress))) {
             this.log.debug('Round executable, but we disagree', {
-                proposal,
+                payload,
                 round
             });
             return;
         }
-        const nextRound = round + 1n;
-        this.log.info(`Waiting for round ${nextRound} to be reached`);
-        const reached = await this.slashingProposer.waitForRound(nextRound, this.config.slashProposerRoundPollingIntervalSeconds);
+        const executableRound = round + BigInt(this.slashingExecutionDelayInRounds) + 1n;
+        this.log.info(`Waiting for round ${executableRound} to be reached`);
+        const reached = await this.slashingProposer.waitForRound(executableRound, this.config.slashProposerRoundPollingIntervalSeconds);
         if (!reached) {
             this.log.warn('Round not reached', {
-                proposal,
+                payload,
                 round
             });
             return;
         }
         this.log.info('Executing round', {
-            proposal,
+            payload,
             round
         });
         await this.slashingProposer.executeRound(this.l1TxUtils, round).then(({ receipt })=>{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/slasher",
-  "version": "1.2.1",
+  "version": "2.0.0-nightly.20250814",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -54,19 +54,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/epoch-cache": "1.2.1",
-    "@aztec/ethereum": "1.2.1",
-    "@aztec/foundation": "1.2.1",
-    "@aztec/l1-artifacts": "1.2.1",
-    "@aztec/stdlib": "1.2.1",
-    "@aztec/telemetry-client": "1.2.1",
+    "@aztec/epoch-cache": "2.0.0-nightly.20250814",
+    "@aztec/ethereum": "2.0.0-nightly.20250814",
+    "@aztec/foundation": "2.0.0-nightly.20250814",
+    "@aztec/l1-artifacts": "2.0.0-nightly.20250814",
+    "@aztec/stdlib": "2.0.0-nightly.20250814",
+    "@aztec/telemetry-client": "2.0.0-nightly.20250814",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "viem": "2.23.7",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@aztec/aztec.js": "1.2.1",
+    "@aztec/aztec.js": "2.0.0-nightly.20250814",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/attestations_block_watcher.ts

@@ -0,0 +1,219 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import {
+  EthAddress,
+  type InvalidBlockDetectedEvent,
+  type L2BlockSourceEventEmitter,
+  L2BlockSourceEvents,
+  PublishedL2Block,
+  type ValidateBlockNegativeResult,
+} from '@aztec/stdlib/block';
+import { Offense } from '@aztec/stdlib/slashing';
+
+import EventEmitter from 'node:events';
+
+import {
+  type SlasherConfig,
+  WANT_TO_SLASH_EVENT,
+  type WantToSlashArgs,
+  type Watcher,
+  type WatcherEmitter,
+} from './config.js';
+
+/**
+ * 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.
+ * The proposer of an invalid block should be slashed.
+ * If there's another block consecutive to the invalid one, its proposer and attestors should also be slashed.
+ */
+export class AttestationsBlockWatcher extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
+  private log: Logger = createLogger('attestations-block-watcher');
+
+  // Only keep track of the last N invalid blocks
+  private maxInvalidBlocks = 100;
+
+  // All invalid archive roots seen
+  private invalidArchiveRoots: Set<string> = new Set();
+
+  // TODO(#16140): Bad validators are never cleared even after slashing
+  private badAttestors: Set<string> = new Set();
+  private badProposers: Set<string> = new Set();
+
+  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,
+        reason: event.validationResult.reason,
+      });
+    }
+  };
+
+  constructor(
+    private l2BlockSource: L2BlockSourceEventEmitter,
+    private epochCache: EpochCache,
+    private config: Pick<
+      SlasherConfig,
+      | 'slashAttestDescendantOfInvalidPenalty'
+      | 'slashAttestDescendantOfInvalidMaxPenalty'
+      | 'slashProposeInvalidAttestationsPenalty'
+      | 'slashProposeInvalidAttestationsMaxPenalty'
+    >,
+  ) {
+    super();
+    this.log.info('InvalidBlockWatcher initialized');
+  }
+
+  public start() {
+    this.l2BlockSource.on(L2BlockSourceEvents.InvalidAttestationsBlockDetected, this.boundHandleInvalidBlock);
+    return Promise.resolve();
+  }
+
+  public stop() {
+    this.l2BlockSource.removeListener(
+      L2BlockSourceEvents.InvalidAttestationsBlockDetected,
+      this.boundHandleInvalidBlock,
+    );
+    return Promise.resolve();
+  }
+
+  public shouldSlash({ amount, offense, validator }: WantToSlashArgs): Promise<boolean> {
+    const maxPenalty = this.getMaxPenalty(offense);
+    const logData = { validator, amount, offense, maxPenalty };
+    if (amount > maxPenalty) {
+      this.log.warn(`Slash amount ${amount} exceeds maximum penalty ${maxPenalty} for offense ${offense}`, logData);
+      return Promise.resolve(false);
+    }
+
+    if (this.hasOffended(offense, validator)) {
+      this.log.verbose(`Agreeing to slash validator ${validator} for offense ${offense}`, logData);
+      return Promise.resolve(true);
+    }
+
+    this.log.debug(`Refusing to slash validator ${validator} for offense ${offense}`, logData);
+    return Promise.resolve(false);
+  }
+
+  private handleInvalidBlock(event: InvalidBlockDetectedEvent): void {
+    const { validationResult } = event;
+    const block = validationResult.block.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}`);
+      return;
+    }
+
+    this.log.verbose(`Detected invalid block ${block.number}`, {
+      ...block.toBlockInfo(),
+      reason: validationResult.valid === false ? validationResult.reason : 'unknown',
+    });
+
+    // Store the invalid block
+    this.addInvalidBlock(event.validationResult.block);
+
+    // Slash the proposer of the invalid block
+    this.slashProposer(event.validationResult);
+
+    // Check if the parent of this block is invalid as well, if so, we will slash its attestors as well
+    this.slashAttestorsOnAncestorInvalid(event.validationResult);
+  }
+
+  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(),
+        ...attestors,
+        parentArchive,
+      });
+
+      attestors.forEach(attestor => this.badAttestors.add(attestor.toString()));
+
+      this.emit(
+        WANT_TO_SLASH_EVENT,
+        attestors.map(attestor => ({
+          validator: attestor,
+          amount: this.config.slashAttestDescendantOfInvalidPenalty,
+          offense: Offense.ATTESTED_DESCENDANT_OF_INVALID,
+        })),
+      );
+    }
+  }
+
+  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);
+
+    if (!proposer) {
+      this.log.warn(`No proposer found for block ${blockNumber} at slot ${slot}`);
+      return;
+    }
+
+    const offense = this.getOffenseFromInvalidationReason(reason);
+    const amount = this.config.slashProposeInvalidAttestationsPenalty;
+    const args: WantToSlashArgs = { validator: proposer, amount, offense };
+
+    this.log.info(`Want to slash proposer of block ${blockNumber} due to ${reason}`, {
+      ...block.block.toBlockInfo(),
+      ...args,
+    });
+
+    this.badProposers.add(proposer.toString());
+    this.emit(WANT_TO_SLASH_EVENT, [args]);
+  }
+
+  private getOffenseFromInvalidationReason(reason: ValidateBlockNegativeResult['reason']): Offense {
+    switch (reason) {
+      case 'invalid-attestation':
+        return Offense.PROPOSED_INCORRECT_ATTESTATIONS;
+      case 'insufficient-attestations':
+        return Offense.PROPOSED_INSUFFICIENT_ATTESTATIONS;
+      default: {
+        const _: never = reason;
+        return Offense.UNKNOWN;
+      }
+    }
+  }
+
+  private getMaxPenalty(offense: Offense) {
+    switch (offense) {
+      case Offense.PROPOSED_INCORRECT_ATTESTATIONS:
+      case Offense.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+        return this.config.slashProposeInvalidAttestationsMaxPenalty;
+      case Offense.ATTESTED_DESCENDANT_OF_INVALID:
+        return this.config.slashProposeInvalidAttestationsMaxPenalty;
+      default:
+        return 0n;
+    }
+  }
+
+  private hasOffended(offense: Offense, validator: EthAddress): boolean {
+    switch (offense) {
+      case Offense.PROPOSED_INCORRECT_ATTESTATIONS:
+      case Offense.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+        return this.badProposers.has(validator.toString());
+      case Offense.ATTESTED_DESCENDANT_OF_INVALID:
+        return this.badAttestors.has(validator.toString());
+      default:
+        return false;
+    }
+  }
+
+  private addInvalidBlock(block: PublishedL2Block) {
+    this.invalidArchiveRoots.add(block.block.archive.root.toString());
+
+    // Prune old entries if we exceed the maximum
+    if (this.invalidArchiveRoots.size > this.maxInvalidBlocks) {
+      const oldestKey = this.invalidArchiveRoots.keys().next().value!;
+      this.invalidArchiveRoots.delete(oldestKey);
+    }
+  }
+}

package/src/config.ts

@@ -1,46 +1,19 @@
+import { NULL_KEY } from '@aztec/ethereum';
 import type { ConfigMappingsType } from '@aztec/foundation/config';
 import {
+  SecretValue,
   bigintConfigHelper,
   booleanConfigHelper,
   floatConfigHelper,
   numberConfigHelper,
+  secretValueConfigHelper,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import { Offense } from '@aztec/stdlib/slashing';
 
-export enum Offense {
-  UNKNOWN = 0,
-  DATA_WITHHOLDING = 1,
-  VALID_EPOCH_PRUNED = 2,
-  INACTIVITY = 3,
-  INVALID_BLOCK = 4,
-}
-
-export const OffenseToBigInt: Record<Offense, bigint> = {
-  [Offense.UNKNOWN]: 0n,
-  [Offense.DATA_WITHHOLDING]: 1n,
-  [Offense.VALID_EPOCH_PRUNED]: 2n,
-  [Offense.INACTIVITY]: 3n,
-  [Offense.INVALID_BLOCK]: 4n,
-};
-
-export function bigIntToOffense(offense: bigint): Offense {
-  switch (offense) {
-    case 0n:
-      return Offense.UNKNOWN;
-    case 1n:
-      return Offense.DATA_WITHHOLDING;
-    case 2n:
-      return Offense.VALID_EPOCH_PRUNED;
-    case 3n:
-      return Offense.INACTIVITY;
-    case 4n:
-      return Offense.INVALID_BLOCK;
-    default:
-      throw new Error(`Unknown offense: ${offense}`);
-  }
-}
+export type { SlasherConfig };
 
 export const WANT_TO_SLASH_EVENT = 'wantToSlash' as const;
 
@@ -79,7 +52,12 @@ export const DefaultSlasherConfig: SlasherConfig = {
   slashInactivitySignalTargetPercentage: 0.6,
   slashInactivityCreatePenalty: 1n,
   slashInactivityMaxPenalty: 100n,
+  slashProposeInvalidAttestationsPenalty: 1n,
+  slashProposeInvalidAttestationsMaxPenalty: 100n,
+  slashAttestDescendantOfInvalidPenalty: 1n,
+  slashAttestDescendantOfInvalidMaxPenalty: 100n,
   slashProposerRoundPollingIntervalSeconds: 12,
+  slasherPrivateKey: new SecretValue<string | undefined>(undefined),
 };
 
 export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
@@ -159,8 +137,32 @@ export const slasherConfigMappings: ConfigMappingsType<SlasherConfig> = {
     description: 'Maximum penalty amount for slashing an inactive validator.',
     ...bigintConfigHelper(DefaultSlasherConfig.slashInactivityMaxPenalty),
   },
+  slashProposeInvalidAttestationsPenalty: {
+    env: 'SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY',
+    description: 'Penalty amount for slashing a proposer that proposed invalid attestations.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashProposeInvalidAttestationsPenalty),
+  },
+  slashProposeInvalidAttestationsMaxPenalty: {
+    env: 'SLASH_PROPOSE_INVALID_ATTESTATIONS_MAX_PENALTY',
+    description: 'Maximum penalty amount for slashing a proposer that proposed invalid attestations.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashProposeInvalidAttestationsMaxPenalty),
+  },
+  slashAttestDescendantOfInvalidPenalty: {
+    env: 'SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY',
+    description: 'Penalty amount for slashing a validator that attested to a descendant of an invalid block.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashAttestDescendantOfInvalidPenalty),
+  },
+  slashAttestDescendantOfInvalidMaxPenalty: {
+    env: 'SLASH_ATTEST_DESCENDANT_OF_INVALID_MAX_PENALTY',
+    description: 'Maximum penalty amount for slashing a validator that attested to a descendant of an invalid block.',
+    ...bigintConfigHelper(DefaultSlasherConfig.slashAttestDescendantOfInvalidMaxPenalty),
+  },
   slashProposerRoundPollingIntervalSeconds: {
     description: 'Polling interval for slashing proposer round in seconds.',
     ...numberConfigHelper(DefaultSlasherConfig.slashProposerRoundPollingIntervalSeconds),
   },
+  slasherPrivateKey: {
+    description: 'Private key used for creating slash payloads.',
+    ...secretValueConfigHelper(val => (val ? `0x${val.replace('0x', '')}` : NULL_KEY)),
+  },
 };

package/src/epoch_prune_watcher.ts

@@ -1,3 +1,4 @@
+import type { Tx } from '@aztec/aztec.js';
 import { EpochCache } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import {
@@ -7,8 +8,9 @@ import {
   type L2BlockSourceEventEmitter,
   L2BlockSourceEvents,
 } from '@aztec/stdlib/block';
-import type { IFullNodeBlockBuilder, ITxCollector, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type { IFullNodeBlockBuilder, ITxProvider, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { Offense } from '@aztec/stdlib/slashing';
 import {
   ReExFailedTxsError,
   ReExStateMismatchError,
@@ -18,7 +20,7 @@ import {
 
 import EventEmitter from 'node:events';
 
-import { Offense, WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from './config.js';
+import { WANT_TO_SLASH_EVENT, type WantToSlashArgs, type Watcher, type WatcherEmitter } from './config.js';
 
 /**
  * This watcher is responsible for detecting chain prunes and creating slashing arguments for the committee.
@@ -34,11 +36,14 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   // Only keep track of the last N slashable epochs
   private maxSlashableEpochs = 100;
 
+  // Store bound function reference for proper listener removal
+  private boundHandlePruneL2Blocks = this.handlePruneL2Blocks.bind(this);
+
   constructor(
     private l2BlockSource: L2BlockSourceEventEmitter,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private epochCache: EpochCache,
-    private txCollector: ITxCollector,
+    private txProvider: Pick<ITxProvider, 'getAvailableTxs'>,
     private blockBuilder: IFullNodeBlockBuilder,
     private penalty: bigint,
     private maxPenalty: bigint,
@@ -48,12 +53,12 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   }
 
   public start() {
-    this.l2BlockSource.on(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
+    this.l2BlockSource.on(L2BlockSourceEvents.L2PruneDetected, this.boundHandlePruneL2Blocks);
     return Promise.resolve();
   }
 
   public stop() {
-    this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
+    this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.boundHandlePruneL2Blocks);
     return Promise.resolve();
   }
 
@@ -120,16 +125,18 @@ export class EpochPruneWatcher extends (EventEmitter as new () => WatcherEmitter
   public async validateBlock(blockFromL1: L2Block, fork: MerkleTreeWriteOperations): Promise<void> {
     this.log.debug(`Validating pruned block ${blockFromL1.header.globalVariables.blockNumber}`);
     const txHashes = blockFromL1.body.txEffects.map(txEffect => txEffect.txHash);
-    const { txs, missing } = await this.txCollector.collectTransactions(
-      txHashes,
-      undefined, // ask from no one in particular
-    );
-    if (missing && missing.length > 0) {
-      throw new TransactionsNotAvailableError(missing);
+    // We load txs from the mempool directly, since the TxCollector running in the background has already been
+    // trying to fetch them from nodes or via reqresp. If we haven't managed to collect them by now,
+    // it's likely that they are not available in the network at all.
+    const { txs, missingTxs } = await this.txProvider.getAvailableTxs(txHashes);
+
+    if (missingTxs && missingTxs.length > 0) {
+      throw new TransactionsNotAvailableError(missingTxs);
     }
+
     const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockFromL1.number);
     const { block, failedTxs, numTxs } = await this.blockBuilder.buildBlock(
-      txs,
+      txs as Tx[],
       l1ToL2Messages,
       blockFromL1.header.globalVariables,
       {},

package/src/index.ts

@@ -1,3 +1,5 @@
 export * from './config.js';
 export * from './epoch_prune_watcher.js';
 export * from './slasher_client.js';
+export * from './attestations_block_watcher.js';
+export * from '@aztec/stdlib/slashing';