@aztec/sequencer-client 0.87.6 → 1.0.0-nightly.20250604

package/src/sequencer/sequencer.ts

@@ -1,24 +1,23 @@
-import { type L2Block, retryUntil } from '@aztec/aztec.js';
+import type { L2Block } from '@aztec/aztec.js';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import type { ViemPublicClient } from '@aztec/ethereum';
+import { FormattedViemError, type ViemPublicClient } from '@aztec/ethereum';
 import { omit } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import type { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { type DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
+import { type DateProvider, Timer } from '@aztec/foundation/timer';
 import type { P2P } from '@aztec/p2p';
 import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
-import type { BlockBuilderFactory } from '@aztec/prover-client/block-builder';
-import type { PublicProcessorFactory } from '@aztec/simulator/server';
+import type { SlasherClient } from '@aztec/slasher';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { CommitteeAttestation, L2BlockSource } from '@aztec/stdlib/block';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import {
   type AllowedElement,
+  type BuildBlockOptions,
+  type IFullNodeBlockBuilder,
   SequencerConfigSchema,
   type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
@@ -27,7 +26,14 @@ import type { BlockProposalOptions } from '@aztec/stdlib/p2p';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
 import type { L2BlockBuiltStats } from '@aztec/stdlib/stats';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { ContentCommitment, GlobalVariables, ProposedBlockHeader, Tx, type TxHash } from '@aztec/stdlib/tx';
+import {
+  ContentCommitment,
+  type FailedTx,
+  GlobalVariables,
+  ProposedBlockHeader,
+  Tx,
+  type TxHash,
+} from '@aztec/stdlib/tx';
 import {
   Attributes,
   L1Metrics,
@@ -40,8 +46,6 @@ import type { ValidatorClient } from '@aztec/validator-client';
 
 import type { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type SequencerPublisher, VoteType } from '../publisher/sequencer-publisher.js';
-import type { SlasherClient } from '../slasher/slasher_client.js';
-import { createValidatorForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
 import type { SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
 import { SequencerTimetable, SequencerTooSlowError } from './timetable.js';
@@ -89,15 +93,13 @@ export class Sequencer {
     protected p2pClient: P2P,
     protected worldState: WorldStateSynchronizer,
     protected slasherClient: SlasherClient,
-    protected blockBuilderFactory: BlockBuilderFactory,
     protected l2BlockSource: L2BlockSource,
     protected l1ToL2MessageSource: L1ToL2MessageSource,
-    protected publicProcessorFactory: PublicProcessorFactory,
-    protected contractDataSource: ContractDataSource,
+    protected blockBuilder: IFullNodeBlockBuilder,
     protected l1Constants: SequencerRollupConstants,
     protected dateProvider: DateProvider,
     protected config: SequencerConfig = {},
-    telemetry: TelemetryClient = getTelemetryClient(),
+    protected telemetry: TelemetryClient = getTelemetryClient(),
     protected log = createLogger('sequencer'),
   ) {
     this.metrics = new SequencerMetrics(
@@ -113,9 +115,6 @@ export class Sequencer {
       [publisher.getSenderAddress()],
     );
 
-    // Register the block builder with the validator client for re-execution
-    this.validatorClient?.registerBlockBuilder(this.buildBlockFromProposal.bind(this));
-
     // Register the slasher on the publisher to fetch slashing payloads
     this.publisher.registerSlashPayloadGetter(this.slasherClient.getSlashPayload.bind(this.slasherClient));
   }
@@ -124,8 +123,8 @@ export class Sequencer {
     return this.metrics.tracer;
   }
 
-  public getValidatorAddress() {
-    return this.validatorClient?.getValidatorAddress();
+  public getValidatorAddresses() {
+    return this.validatorClient?.getValidatorAddresses();
   }
 
   /**
@@ -217,7 +216,7 @@ export class Sequencer {
     this.metrics.stop();
     await this.validatorClient?.stop();
     await this.runningPromise?.stop();
-    this.slasherClient.stop();
+    await this.slasherClient.stop();
     this.publisher.interrupt();
     this.setState(SequencerState.STOPPED, 0n, true /** force */);
     this.l1Metrics.stop();
@@ -271,10 +270,19 @@ export class Sequencer {
     // If we cannot find a tip archive, assume genesis.
     const chainTipArchive = chainTip.archive;
 
-    const slot = await this.slotForProposal(chainTipArchive.toBuffer(), BigInt(newBlockNumber));
+    const { slot } = this.publisher.epochCache.getEpochAndSlotInNextSlot();
     this.metrics.observeSlotChange(slot, this.publisher.getSenderAddress().toString());
-    if (!slot) {
-      this.log.debug(`Cannot propose block ${newBlockNumber}`);
+
+    const proposerInNextSlot = await this.publisher.epochCache.getProposerAttesterAddressInNextSlot();
+    const validatorAddresses = this.validatorClient!.getValidatorAddresses();
+
+    // If get proposer in next slot is undefined, then there is no proposer set, and it is in free for all (sandbox) so we continue
+    // If we calculate a proposer in the next slot, and it is not us, then stop
+    if (proposerInNextSlot !== undefined && !validatorAddresses.some(addr => addr.equals(proposerInNextSlot))) {
+      this.log.debug(`Cannot propose block ${newBlockNumber}`, {
+        us: validatorAddresses,
+        proposer: proposerInNextSlot,
+      });
       return;
     }
 
@@ -316,14 +324,22 @@ export class Sequencer {
 
     let finishedFlushing = false;
     const pendingTxCount = await this.p2pClient.getPendingTxCount();
+    this.log.debug(`Pending tx count: ${pendingTxCount}`);
     if (pendingTxCount >= this.minTxsPerBlock || this.isFlushing) {
       // We don't fetch exactly maxTxsPerBlock txs here because we may not need all of them if we hit a limit before,
       // and also we may need to fetch more if we don't have enough valid txs.
       const pendingTxs = this.p2pClient.iteratePendingTxs();
 
-      await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables).catch(err => {
-        this.log.error(`Error building/enqueuing block`, err, { blockNumber: newBlockNumber, slot });
-      });
+      await this.buildBlockAndEnqueuePublish(pendingTxs, proposalHeader, newGlobalVariables, proposerInNextSlot).catch(
+        err => {
+          if (err instanceof FormattedViemError) {
+            this.log.verbose(`Unable to build/enqueue block ${err.message}`);
+            return;
+          } else {
+            this.log.error(`Error building/enqueuing block`, err, { blockNumber: newBlockNumber, slot });
+          }
+        },
+      );
       finishedFlushing = true;
     } else {
       this.log.verbose(
@@ -374,29 +390,6 @@ export class Sequencer {
     return this.publisher.getForwarderAddress();
   }
 
-  /**
-   * Checks if we can propose at the next block and returns the slot number if we can.
-   * @param tipArchive - The archive of the previous block.
-   * @param proposalBlockNumber - The block number of the proposal.
-   * @returns The slot number if we can propose at the next block, otherwise undefined.
-   */
-  async slotForProposal(tipArchive: Buffer, proposalBlockNumber: bigint): Promise<bigint | undefined> {
-    const result = await this.publisher.canProposeAtNextEthBlock(tipArchive);
-
-    if (!result) {
-      return undefined;
-    }
-
-    const [slot, blockNumber] = result;
-
-    if (proposalBlockNumber !== blockNumber) {
-      const msg = `Sequencer block number mismatch. Expected ${proposalBlockNumber} but got ${blockNumber}.`;
-      this.log.warn(msg);
-      throw new Error(msg);
-    }
-    return slot;
-  }
-
   /**
    * Sets the sequencer state and checks if we have enough time left in the slot to transition to the new state.
    * @param proposedState - The new state to transition to.
@@ -417,175 +410,32 @@ export class Sequencer {
     this.state = proposedState;
   }
 
-  /**
-   * Build a block
-   *
-   * @param pendingTxs - The pending transactions to construct the block from
-   * @param newGlobalVariables - The global variables for the new block
-   * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
-   */
-  protected async buildBlock(
-    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
-    newGlobalVariables: GlobalVariables,
-    opts: { validateOnly?: boolean } = {},
-  ) {
-    const blockNumber = newGlobalVariables.blockNumber.toNumber();
-    const slot = newGlobalVariables.slotNumber.toBigInt();
-    this.log.debug(`Requesting L1 to L2 messages from contract for block ${blockNumber}`);
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(blockNumber));
-    const msgCount = l1ToL2Messages.length;
-
-    this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
-      slot,
-      blockNumber,
-      msgCount,
-      validator: opts.validateOnly,
-    });
-
-    // Sync to the previous block at least. If we cannot sync to that block because the archiver hasn't caught up,
-    // we keep retrying until the reexecution deadline. Note that this could only happen when we are a validator,
-    // for if we are the proposer, then world-state should already be caught up, as we check this earlier.
-    await retryUntil(
-      () => this.worldState.syncImmediate(blockNumber - 1, true).then(syncedTo => syncedTo >= blockNumber - 1),
-      'sync to previous block',
-      this.timetable.getValidatorReexecTimeEnd(),
-      0.1,
-    );
-    this.log.debug(`Synced to previous block ${blockNumber - 1}`);
-
-    // NB: separating the dbs because both should update the state
-    const publicProcessorDBFork = await this.worldState.fork();
-    const orchestratorDBFork = await this.worldState.fork();
-
-    const previousBlockHeader =
-      (await this.l2BlockSource.getBlock(blockNumber - 1))?.header ?? orchestratorDBFork.getInitialHeader();
-
-    try {
-      const processor = this.publicProcessorFactory.create(publicProcessorDBFork, newGlobalVariables, true);
-      const blockBuildingTimer = new Timer();
-      const blockBuilder = this.blockBuilderFactory.create(orchestratorDBFork);
-      await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages, previousBlockHeader);
-
-      // Deadline for processing depends on whether we're proposing a block
-      const secondsIntoSlot = this.getSecondsIntoSlot(slot);
-      const processingEndTimeWithinSlot = opts.validateOnly
-        ? this.timetable.getValidatorReexecTimeEnd(secondsIntoSlot)
-        : this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
-
-      // Deadline is only set if enforceTimeTable is enabled.
-      const deadline = this.enforceTimeTable
-        ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000)
-        : undefined;
-
-      this.log.verbose(`Processing pending txs`, {
-        slot,
-        slotStart: new Date(this.getSlotStartTimestamp(slot) * 1000),
-        now: new Date(this.dateProvider.now()),
-        deadline,
-      });
-
-      const validator = createValidatorForBlockBuilding(
-        publicProcessorDBFork,
-        this.contractDataSource,
-        newGlobalVariables,
-        this.txPublicSetupAllowList,
-      );
-
-      // TODO(#11000): Public processor should just handle processing, one tx at a time. It should be responsibility
-      // of the sequencer to update world state and iterate over txs. We should refactor this along with unifying the
-      // publicProcessorFork and orchestratorFork, to avoid doing tree insertions twice when building the block.
-      const proposerLimits = {
-        maxTransactions: this.maxTxsPerBlock,
-        maxBlockSize: this.maxBlockSizeInBytes,
-        maxBlockGas: this.maxBlockGas,
-      };
-      const limits = opts.validateOnly ? { deadline } : { deadline, ...proposerLimits };
-      const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(() =>
-        processor.process(pendingTxs, limits, validator),
-      );
-
-      if (!opts.validateOnly && failedTxs.length > 0) {
-        const failedTxData = failedTxs.map(fail => fail.tx);
-        const failedTxHashes = await Tx.getHashes(failedTxData);
-        this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
-        await this.p2pClient.deleteTxs(failedTxHashes);
-      }
-
-      if (
-        !opts.validateOnly && // We check for minTxCount only if we are proposing a block, not if we are validating it
-        !this.isFlushing && // And we skip the check when flushing, since we want all pending txs to go out, no matter if too few
-        this.minTxsPerBlock !== undefined &&
-        processedTxs.length < this.minTxsPerBlock
-      ) {
-        this.log.warn(
-          `Block ${blockNumber} has too few txs to be proposed (got ${processedTxs.length} but required ${this.minTxsPerBlock})`,
-          { slot, blockNumber, processedTxCount: processedTxs.length },
-        );
-        throw new Error(`Block has too few successful txs to be proposed`);
-      }
-
-      const start = process.hrtime.bigint();
-      await blockBuilder.addTxs(processedTxs);
-      const end = process.hrtime.bigint();
-      const duration = Number(end - start) / 1_000;
-      this.metrics.recordBlockBuilderTreeInsertions(duration);
-
-      // All real transactions have been added, set the block as full and pad if needed
-      const block = await blockBuilder.setBlockCompleted();
-
-      // How much public gas was processed
-      const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
-
-      return {
-        block,
-        publicGas,
-        publicProcessorDuration,
-        numMsgs: l1ToL2Messages.length,
-        numTxs: processedTxs.length,
-        numFailedTxs: failedTxs.length,
-        blockBuildingTimer,
-        usedTxs,
-      };
-    } finally {
-      // We create a fresh processor each time to reset any cached state (eg storage writes)
-      // We wait a bit to close the forks since the processor may still be working on a dangling tx
-      // which was interrupted due to the processingDeadline being hit.
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      setTimeout(async () => {
-        try {
-          await publicProcessorDBFork.close();
-          await orchestratorDBFork.close();
-        } catch (err) {
-          // This can happen if the sequencer is stopped before we hit this timeout.
-          this.log.warn(`Error closing forks for block processing`, err);
-        }
-      }, 5000);
+  private async dropFailedTxsFromP2P(failedTxs: FailedTx[]) {
+    if (failedTxs.length === 0) {
+      return;
     }
+    const failedTxData = failedTxs.map(fail => fail.tx);
+    const failedTxHashes = await Tx.getHashes(failedTxData);
+    this.log.verbose(`Dropping failed txs ${failedTxHashes.join(', ')}`);
+    await this.p2pClient.deleteTxs(failedTxHashes);
   }
 
-  /**
-   * Build a block from a proposal. Used by the validator to re-execute transactions.
-   *
-   * @param blockNumber - The block number of the proposal.
-   * @param header - The header of the proposal.
-   * @param pendingTxs - The pending transactions to construct the block from.
-   * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal.
-   */
-  async buildBlockFromProposal(
-    blockNumber: Fr,
-    header: ProposedBlockHeader,
-    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
-    opts: { validateOnly?: boolean } = {},
-  ) {
-    const { chainId, version } = await this.globalsBuilder.getGlobalConstantVariables();
-    const globalVariables = GlobalVariables.from({
-      ...header,
-      blockNumber,
-      timestamp: new Fr(header.timestamp),
-      chainId,
-      version,
-    });
-    return await this.buildBlock(pendingTxs, globalVariables, opts);
+  protected getDefaultBlockBuilderOptions(slot: number): BuildBlockOptions {
+    // Deadline for processing depends on whether we're proposing a block
+    const secondsIntoSlot = this.getSecondsIntoSlot(slot);
+    const processingEndTimeWithinSlot = this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
+
+    // Deadline is only set if enforceTimeTable is enabled.
+    const deadline = this.enforceTimeTable
+      ? new Date((this.getSlotStartTimestamp(slot) + processingEndTimeWithinSlot) * 1000)
+      : undefined;
+    return {
+      maxTransactions: this.maxTxsPerBlock,
+      maxBlockSize: this.maxBlockSizeInBytes,
+      maxBlockGas: this.maxBlockGas,
+      txPublicSetupAllowList: this.txPublicSetupAllowList,
+      deadline,
+    };
   }
 
   /**
@@ -596,6 +446,8 @@ export class Sequencer {
    *
    * @param pendingTxs - Iterable of pending transactions to construct the block from
    * @param proposalHeader - The partial header constructed for the proposal
+   * @param newGlobalVariables - The global variables for the new block
+   * @param proposerAddress - The address of the proposer
    */
   @trackSpan('Sequencer.buildBlockAndEnqueuePublish', (_validTxs, _proposalHeader, newGlobalVariables) => ({
     [Attributes.BLOCK_NUMBER]: newGlobalVariables.blockNumber.toNumber(),
@@ -604,6 +456,7 @@ export class Sequencer {
     pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
     proposalHeader: ProposedBlockHeader,
     newGlobalVariables: GlobalVariables,
+    proposerAddress: EthAddress,
   ): Promise<void> {
     await this.publisher.validateBlockForSubmission(proposalHeader);
 
@@ -615,9 +468,22 @@ export class Sequencer {
     this.setState(SequencerState.CREATING_BLOCK, slot);
 
     try {
-      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables);
-      const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer, usedTxs } = buildBlockRes;
+      const blockBuilderOptions = this.getDefaultBlockBuilderOptions(Number(slot));
+      const buildBlockRes = await this.blockBuilder.buildBlock(pendingTxs, newGlobalVariables, blockBuilderOptions);
+      const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer, usedTxs, failedTxs } =
+        buildBlockRes;
       this.metrics.recordBuiltBlock(workTimer.ms(), publicGas.l2Gas);
+      await this.dropFailedTxsFromP2P(failedTxs);
+
+      const minTxsPerBlock = this.isFlushing ? 0 : this.minTxsPerBlock;
+
+      if (numTxs < minTxsPerBlock) {
+        this.log.warn(
+          `Block ${blockNumber} has too few txs to be proposed (got ${numTxs} but required ${minTxsPerBlock})`,
+          { slot, blockNumber, numTxs },
+        );
+        throw new Error(`Block has too few successful txs to be proposed`);
+      }
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
@@ -648,7 +514,7 @@ export class Sequencer {
 
       this.log.debug('Collecting attestations');
       const stopCollectingAttestationsTimer = this.metrics.startCollectingAttestationsTimer();
-      const attestations = await this.collectAttestations(block, usedTxs);
+      const attestations = await this.collectAttestations(block, usedTxs, proposerAddress);
       if (attestations !== undefined) {
         this.log.verbose(`Collected ${attestations.length} attestations`, { blockHash, blockNumber });
       }
@@ -666,7 +532,11 @@ export class Sequencer {
     [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
     [Attributes.BLOCK_TXS_COUNT]: txHashes.length,
   }))
-  protected async collectAttestations(block: L2Block, txs: Tx[]): Promise<Signature[] | undefined> {
+  protected async collectAttestations(
+    block: L2Block,
+    txs: Tx[],
+    proposerAddress: EthAddress,
+  ): Promise<CommitteeAttestation[] | undefined> {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962): inefficient to have a round trip in here - this should be cached
     const committee = await this.publisher.getCurrentEpochCommittee();
 
@@ -695,6 +565,7 @@ export class Sequencer {
       block.archive.root,
       block.header.state,
       txs,
+      proposerAddress,
       blockProposalOptions,
     );
     if (!proposal) {
@@ -728,7 +599,7 @@ export class Sequencer {
   }))
   protected async enqueuePublishL2Block(
     block: L2Block,
-    attestations?: Signature[],
+    attestations?: CommitteeAttestation[],
     txHashes?: TxHash[],
   ): Promise<void> {
     // Publishes new block to the network and awaits the tx to be mined
@@ -823,4 +694,8 @@ export class Sequencer {
   get maxL2BlockGas(): number | undefined {
     return this.config.maxL2BlockGas;
   }
+
+  public getSlasherClient(): SlasherClient {
+    return this.slasherClient;
+  }
 }

package/src/sequencer/utils.ts

@@ -1,5 +1,5 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Signature } from '@aztec/foundation/eth-signature';
+import { CommitteeAttestation } from '@aztec/stdlib/block';
 import type { BlockAttestation } from '@aztec/stdlib/p2p';
 
 export enum SequencerState {
@@ -50,19 +50,27 @@ export function sequencerStateToNumber(state: SequencerState): number {
  *
  * @todo: perform this logic within the memory attestation store instead?
  */
-export function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): Signature[] {
+export function orderAttestations(
+  attestations: BlockAttestation[],
+  orderAddresses: EthAddress[],
+): CommitteeAttestation[] {
   // Create a map of sender addresses to BlockAttestations
-  const attestationMap = new Map<string, BlockAttestation>();
+  const attestationMap = new Map<string, CommitteeAttestation>();
 
   for (const attestation of attestations) {
     const sender = attestation.getSender();
-    attestationMap.set(sender.toString(), attestation);
+    if (sender) {
+      attestationMap.set(
+        sender.toString(),
+        CommitteeAttestation.fromAddressAndSignature(sender, attestation.signature),
+      );
+    }
   }
 
-  // Create the ordered array based on the orderAddresses, else return an empty signature
+  // Create the ordered array based on the orderAddresses, else return an empty attestation
   const orderedAttestations = orderAddresses.map(address => {
     const addressString = address.toString();
-    return attestationMap.get(addressString)?.signature || Signature.empty();
+    return attestationMap.get(addressString) || CommitteeAttestation.fromAddress(address);
   });
 
   return orderedAttestations;

package/src/tx_validator/tx_validator_factory.ts

@@ -18,6 +18,7 @@ import type {
   AllowedElement,
   ClientProtocolCircuitVerifier,
   MerkleTreeReadOperations,
+  PublicProcessorValidator,
 } from '@aztec/stdlib/interfaces/server';
 import { DatabasePublicStateSource, type PublicStateSource } from '@aztec/stdlib/trees';
 import { GlobalVariables, type Tx, type TxValidator } from '@aztec/stdlib/tx';
@@ -74,10 +75,7 @@ export function createValidatorForBlockBuilding(
   contractDataSource: ContractDataSource,
   globalVariables: GlobalVariables,
   setupAllowList: AllowedElement[],
-): {
-  preprocessValidator: TxValidator<Tx>;
-  nullifierCache: NullifierCache;
-} {
+): PublicProcessorValidator {
   const nullifierCache = new NullifierCache(db);
   const archiveCache = new ArchiveCache(db);
   const publicStateSource = new DatabasePublicStateSource(db);

package/dest/slasher/factory.d.ts

@@ -1,7 +0,0 @@
-import type { L1ContractsConfig, L1ReaderConfig } from '@aztec/ethereum';
-import type { L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import { SlasherClient } from './slasher_client.js';
-import type { SlasherConfig } from './slasher_client.js';
-export declare const createSlasherClient: (_config: SlasherConfig & L1ContractsConfig & L1ReaderConfig, l2BlockSource: L2BlockSourceEventEmitter, telemetry?: TelemetryClient) => SlasherClient;
-//# sourceMappingURL=factory.d.ts.map

package/dest/slasher/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/slasher/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,eAAO,MAAM,mBAAmB,GAC9B,SAAS,aAAa,GAAG,iBAAiB,GAAG,cAAc,EAC3D,eAAe,yBAAyB,EACxC,YAAW,eAAsC,kBAIlD,CAAC"}

package/dest/slasher/factory.js

@@ -1,8 +0,0 @@
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import { SlasherClient } from './slasher_client.js';
-export const createSlasherClient = (_config, l2BlockSource, telemetry = getTelemetryClient())=>{
-    const config = {
-        ..._config
-    };
-    return new SlasherClient(config, l2BlockSource, telemetry);
-};

package/dest/slasher/index.d.ts

@@ -1,3 +0,0 @@
-export * from './slasher_client.js';
-export { createSlasherClient } from './factory.js';
-//# sourceMappingURL=index.d.ts.map

package/dest/slasher/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/slasher/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}

package/dest/slasher/index.js

@@ -1,2 +0,0 @@
-export * from './slasher_client.js';
-export { createSlasherClient } from './factory.js';

package/dest/slasher/slasher_client.d.ts

@@ -1,75 +0,0 @@
-import { type L1ContractsConfig, type L1ReaderConfig, type ViemPublicClient } from '@aztec/ethereum';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { SlashFactoryAbi } from '@aztec/l1-artifacts';
-import { type L2BlockId, type L2BlockSourceEvent, type L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
-import { type TelemetryClient, WithTracer } from '@aztec/telemetry-client';
-import { type GetContractReturnType } from 'viem';
-/**
- * Enum defining the possible states of the Slasher client.
- */
-export declare enum SlasherClientState {
-    IDLE = 0,
-    RUNNING = 1,
-    STOPPED = 2
-}
-/**
- * The synchronization status of the Slasher client.
- */
-export interface SlasherSyncState {
-    /**
-     * The current state of the slasher client.
-     */
-    state: SlasherClientState;
-    /**
-     * The block number that the slasher client is synced to.
-     */
-    syncedToL2Block: L2BlockId;
-}
-export interface SlasherConfig {
-    blockCheckIntervalMS: number;
-    blockRequestBatchSize: number;
-}
-/**
- * @notice A Hypomeiones slasher client implementation
- *
- * Hypomeiones: a class of individuals in ancient Sparta who were considered inferior or lesser citizens compared
- * to the full Spartan citizens.
- *
- * The implementation here is less than ideal. It exists, not to be the end all be all, but to show that
- * slashing can be done with this mechanism.
- *
- * The implementation is VERY brute in the sense that it only looks for pruned blocks and then tries to slash
- * the full committee of that.
- * If it sees a prune, it will mark the full epoch as "to be slashed".
- *
- * Also, it is not particularly smart around what it should if there were to be multiple slashing events.
- *
- * A few improvements:
- * - Only vote on the proposal if it is possible to reach, e.g., if 6 votes are needed and only 4 slots are left don't vote.
- * - Stop voting on a payload once it is processed.
- * - Only vote on the proposal if it have not already been executed
- *  - Caveat, we need to fully decide if it is acceptable to have the same payload address multiple times. In the current
- *    slash factory that could mean slashing the same committee for the same error multiple times.
- * - Decide how to deal with multiple slashing events in the same round.
- *  - This could be that multiple epochs are pruned in the same round, but with the current naive implementation we could end up
- *    slashing only the first, because the "lifetime" of the second would have passed after that vote
- */
-export declare class SlasherClient extends WithTracer {
-    private config;
-    private l2BlockSource;
-    private log;
-    private slashEvents;
-    protected slashFactoryContract?: GetContractReturnType<typeof SlashFactoryAbi, ViemPublicClient>;
-    private slashingAmount;
-    constructor(config: SlasherConfig & L1ContractsConfig & L1ReaderConfig, l2BlockSource: L2BlockSourceEventEmitter, telemetry?: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
-    start(): void;
-    getSlashPayload(slotNumber: bigint): Promise<EthAddress | undefined>;
-    handleBlockStreamEvent(event: L2BlockSourceEvent): 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(): void;
-    private handlePruneL2Blocks;
-}
-//# sourceMappingURL=slasher_client.d.ts.map

package/dest/slasher/slasher_client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slasher_client.d.ts","sourceRoot":"","sources":["../../src/slasher/slasher_client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EAEtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EACL,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAE/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAsB,MAAM,yBAAyB,CAAC;AAE/F,OAAO,EAAE,KAAK,qBAAqB,EAA+D,MAAM,MAAM,CAAC;AAE/G;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,OAAO,IAAA;CACR;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,EAAE,kBAAkB,CAAC;IAC1B;;OAEG;IACH,eAAe,EAAE,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAQD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,aAAc,SAAQ,UAAU;IAWzC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,aAAa;IAErB,OAAO,CAAC,GAAG;IAbb,OAAO,CAAC,WAAW,CAAoB;IAEvC,SAAS,CAAC,oBAAoB,CAAC,EAAE,qBAAqB,CAAC,OAAO,eAAe,EAAE,gBAAgB,CAAC,CAAa;IAK7G,OAAO,CAAC,cAAc,CAAc;gBAG1B,MAAM,EAAE,aAAa,GAAG,iBAAiB,GAAG,cAAc,EAC1D,aAAa,EAAE,yBAAyB,EAChD,SAAS,GAAE,eAAsC,EACzC,GAAG,yCAA0B;IAwBhC,KAAK;IAMC,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;IAgC1E,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAavE;;;OAGG;IACI,IAAI;IAMX,OAAO,CAAC,mBAAmB;CAqB5B"}