@aztec/sequencer-client 0.69.1 → 0.71.0

package/src/sequencer/sequencer.ts

@@ -21,6 +21,7 @@ import {
   type GlobalVariables,
   StateReference,
 } from '@aztec/circuits.js';
+import { prettyLogViemErrorMsg } from '@aztec/ethereum';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { omit } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -31,36 +32,22 @@ import { pickFromSchema } from '@aztec/foundation/schemas';
 import { type DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
 import { type P2P } from '@aztec/p2p';
 import { type BlockBuilderFactory } from '@aztec/prover-client/block-builder';
-import { type PublicProcessorFactory } from '@aztec/simulator';
-import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { type PublicProcessorFactory } from '@aztec/simulator/server';
+import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { type ValidatorClient } from '@aztec/validator-client';
 
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type L1Publisher, VoteType } from '../publisher/l1-publisher.js';
-import { prettyLogViemErrorMsg } from '../publisher/utils.js';
 import { type SlasherClient } from '../slasher/slasher_client.js';
 import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
 import { getDefaultAllowedSetupFunctions } from './allowed.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
+import { SequencerTimetable, SequencerTooSlowError } from './timetable.js';
 import { SequencerState, orderAttestations } from './utils.js';
 
 export { SequencerState };
 
-export class SequencerTooSlowError extends Error {
-  constructor(
-    public readonly currentState: SequencerState,
-    public readonly proposedState: SequencerState,
-    public readonly maxAllowedTime: number,
-    public readonly currentTime: number,
-  ) {
-    super(
-      `Too far into slot to transition to ${proposedState} (max allowed: ${maxAllowedTime}s, time into slot: ${currentTime}s)`,
-    );
-    this.name = 'SequencerTooSlowError';
-  }
-}
-
 type SequencerRollupConstants = Pick<L1RollupConstants, 'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration'>;
 
 /**
@@ -76,7 +63,7 @@ export class Sequencer {
   private runningPromise?: RunningPromise;
   private pollingIntervalMs: number = 1000;
   private maxTxsPerBlock = 32;
-  private minTxsPerBLock = 1;
+  private minTxsPerBlock = 1;
   private maxL1TxInclusionTimeIntoSlot = 0;
   // TODO: zero values should not be allowed for the following 2 values in PROD
   private _coinbase = EthAddress.ZERO;
@@ -84,35 +71,32 @@ export class Sequencer {
   private state = SequencerState.STOPPED;
   private allowedInSetup: AllowedElement[] = getDefaultAllowedSetupFunctions();
   private maxBlockSizeInBytes: number = 1024 * 1024;
-  private maxBlockGas: Gas = new Gas(10e9, 10e9);
-  private processTxTime: number = 12;
+  private maxBlockGas: Gas = new Gas(100e9, 100e9);
   private metrics: SequencerMetrics;
   private isFlushing: boolean = false;
 
-  /**
-   * The maximum number of seconds that the sequencer can be into a slot to transition to a particular state.
-   * For example, in order to transition into WAITING_FOR_ATTESTATIONS, the sequencer can be at most 3 seconds into the slot.
-   */
-  protected timeTable!: Record<SequencerState, number>;
+  /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */
+  protected timetable!: SequencerTimetable;
+
   protected enforceTimeTable: boolean = false;
 
   constructor(
-    private publisher: L1Publisher,
-    private validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
-    private globalsBuilder: GlobalVariableBuilder,
-    private p2pClient: P2P,
-    private worldState: WorldStateSynchronizer,
-    private slasherClient: SlasherClient,
-    private blockBuilderFactory: BlockBuilderFactory,
-    private l2BlockSource: L2BlockSource,
-    private l1ToL2MessageSource: L1ToL2MessageSource,
-    private publicProcessorFactory: PublicProcessorFactory,
-    private contractDataSource: ContractDataSource,
+    protected publisher: L1Publisher,
+    protected validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
+    protected globalsBuilder: GlobalVariableBuilder,
+    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 l1Constants: SequencerRollupConstants,
-    private dateProvider: DateProvider,
-    telemetry: TelemetryClient,
-    private config: SequencerConfig = {},
-    private log = createLogger('sequencer'),
+    protected dateProvider: DateProvider,
+    protected config: SequencerConfig = {},
+    telemetry: TelemetryClient = getTelemetryClient(),
+    protected log = createLogger('sequencer'),
   ) {
     this.updateConfig(config);
     this.metrics = new SequencerMetrics(telemetry, () => this.state, 'Sequencer');
@@ -142,7 +126,7 @@ export class Sequencer {
       this.maxTxsPerBlock = config.maxTxsPerBlock;
     }
     if (config.minTxsPerBlock !== undefined) {
-      this.minTxsPerBLock = config.minTxsPerBlock;
+      this.minTxsPerBlock = config.minTxsPerBlock;
     }
     if (config.maxDABlockGas !== undefined) {
       this.maxBlockGas = new Gas(config.maxDABlockGas, this.maxBlockGas.l2Gas);
@@ -168,7 +152,9 @@ export class Sequencer {
     if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
       this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
     }
-    this.enforceTimeTable = config.enforceTimeTable === true;
+    if (config.enforceTimeTable !== undefined) {
+      this.enforceTimeTable = config.enforceTimeTable;
+    }
 
     this.setTimeTable();
 
@@ -177,60 +163,15 @@ export class Sequencer {
   }
 
   private setTimeTable() {
-    // How late into the slot can we be to start working
-    const initialTime = 2;
-
-    // How long it takes to get ready to start building
-    const blockPrepareTime = 1;
-
-    // How long it takes to for attestations to travel across the p2p layer.
-    const attestationPropagationTime = 2;
-
-    // How long it takes to get a published block into L1. L1 builders typically accept txs up to 4 seconds into their slot,
-    // but we'll timeout sooner to give it more time to propagate (remember we also have blobs!). Still, when working in anvil,
-    // we can just post in the very last second of the L1 slot.
-    const l1PublishingTime = this.l1Constants.ethereumSlotDuration - this.maxL1TxInclusionTimeIntoSlot;
-
-    // How much time we spend validating and processing a block after building it
-    const blockValidationTime = 1;
-
-    // How much time we have left in the slot for actually processing txs and building the block.
-    const remainingTimeInSlot =
-      this.aztecSlotDuration -
-      initialTime -
-      blockPrepareTime -
-      l1PublishingTime -
-      2 * attestationPropagationTime -
-      blockValidationTime;
-
-    // Check that numbers make sense
-    if (this.enforceTimeTable && remainingTimeInSlot < 0) {
-      throw new Error(`Not enough time for block building in ${this.aztecSlotDuration}s slot`);
-    }
-
-    // How much time we have for actually processing txs. Note that we need both the sequencer and the validators to execute txs.
-    const processTxsTime = remainingTimeInSlot / 2;
-    this.processTxTime = processTxsTime;
-
-    const newTimeTable: Record<SequencerState, number> = {
-      // No checks needed for any of these transitions
-      [SequencerState.STOPPED]: this.aztecSlotDuration,
-      [SequencerState.IDLE]: this.aztecSlotDuration,
-      [SequencerState.SYNCHRONIZING]: this.aztecSlotDuration,
-      // We always want to allow the full slot to check if we are the proposer
-      [SequencerState.PROPOSER_CHECK]: this.aztecSlotDuration,
-      // How late we can start initializing a new block proposal
-      [SequencerState.INITIALIZING_PROPOSAL]: initialTime,
-      // When we start building a block
-      [SequencerState.CREATING_BLOCK]: initialTime + blockPrepareTime,
-      // We start collecting attestations after building the block
-      [SequencerState.COLLECTING_ATTESTATIONS]: initialTime + blockPrepareTime + processTxsTime + blockValidationTime,
-      // We publish the block after collecting attestations
-      [SequencerState.PUBLISHING_BLOCK]: this.aztecSlotDuration - l1PublishingTime,
-    };
-
-    this.log.verbose(`Sequencer time table updated with ${processTxsTime}s for processing txs`, newTimeTable);
-    this.timeTable = newTimeTable;
+    this.timetable = new SequencerTimetable(
+      this.l1Constants.ethereumSlotDuration,
+      this.aztecSlotDuration,
+      this.maxL1TxInclusionTimeIntoSlot,
+      this.enforceTimeTable,
+      this.metrics,
+      this.log,
+    );
+    this.log.verbose(`Sequencer timetable updated`, { enforceTimeTable: this.enforceTimeTable });
   }
 
   /**
@@ -326,8 +267,8 @@ export class Sequencer {
 
     // Check the pool has enough txs to build a block
     const pendingTxCount = this.p2pClient.getPendingTxCount();
-    if (pendingTxCount < this.minTxsPerBLock && !this.isFlushing) {
-      this.log.verbose(`Not enough txs to propose block. Got ${pendingTxCount} min ${this.minTxsPerBLock}.`, {
+    if (pendingTxCount < this.minTxsPerBlock && !this.isFlushing) {
+      this.log.verbose(`Not enough txs to propose block. Got ${pendingTxCount} min ${this.minTxsPerBlock}.`, {
         slot,
         blockNumber: newBlockNumber,
       });
@@ -404,29 +345,6 @@ export class Sequencer {
     }
   }
 
-  doIHaveEnoughTimeLeft(proposedState: SequencerState, secondsIntoSlot: number): boolean {
-    if (!this.enforceTimeTable) {
-      return true;
-    }
-
-    const maxAllowedTime = this.timeTable[proposedState];
-    if (maxAllowedTime === this.aztecSlotDuration) {
-      return true;
-    }
-
-    const bufferSeconds = maxAllowedTime - secondsIntoSlot;
-
-    if (bufferSeconds < 0) {
-      this.log.debug(`Too far into slot to transition to ${proposedState}`, { maxAllowedTime, secondsIntoSlot });
-      return false;
-    }
-
-    this.metrics.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), proposedState);
-
-    this.log.trace(`Enough time to transition to ${proposedState}`, { maxAllowedTime, secondsIntoSlot });
-    return true;
-  }
-
   /**
    * 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.
@@ -442,9 +360,7 @@ export class Sequencer {
       return;
     }
     const secondsIntoSlot = this.getSecondsIntoSlot(currentSlotNumber);
-    if (!this.doIHaveEnoughTimeLeft(proposedState, secondsIntoSlot)) {
-      throw new SequencerTooSlowError(this.state, proposedState, this.timeTable[proposedState], secondsIntoSlot);
-    }
+    this.timetable.assertTimeLeft(proposedState, secondsIntoSlot);
     this.log.debug(`Transitioning from ${this.state} to ${proposedState}`);
     this.state = proposedState;
   }
@@ -459,7 +375,7 @@ export class Sequencer {
    * @param historicalHeader - The historical header of the parent
    * @param opts - Whether to just validate the block as a validator, as opposed to building it as a proposal
    */
-  private async buildBlock(
+  protected async buildBlock(
     pendingTxs: Iterable<Tx>,
     newGlobalVariables: GlobalVariables,
     historicalHeader?: BlockHeader,
@@ -472,7 +388,12 @@ export class Sequencer {
     const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
     const msgCount = l1ToL2Messages.length;
 
-    this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, { slot, blockNumber, msgCount });
+    this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
+      slot,
+      blockNumber,
+      msgCount,
+      validator: opts.validateOnly,
+    });
 
     // Sync to the previous block at least
     await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
@@ -493,12 +414,17 @@ export class Sequencer {
       const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
       await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages);
 
-      // We set the deadline for tx processing to the start of the CREATING_BLOCK phase, plus the expected time for tx processing.
+      // 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 processingEndTimeWithinSlot = this.timeTable[SequencerState.CREATING_BLOCK] + this.processTxTime;
       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),
@@ -514,15 +440,20 @@ export class Sequencer {
         this.allowedInSetup,
       );
 
-      // REFACTOR: Public processor should just handle processing, one tx at a time. It should be responsibility
+      // 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 limits = { deadline, maxTransactions: this.maxTxsPerBlock, maxBlockSize: this.maxBlockSizeInBytes };
+      const proposerLimits = {
+        maxTransactions: this.maxTxsPerBlock,
+        maxBlockSize: this.maxBlockSizeInBytes,
+        maxBlockGas: this.maxBlockGas,
+      };
+      const limits = opts.validateOnly ? { deadline } : { deadline, ...proposerLimits };
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
         processor.process(pendingTxs, limits, validators),
       );
 
-      if (failedTxs.length > 0) {
+      if (!opts.validateOnly && failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
         this.log.verbose(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
         await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
@@ -531,11 +462,11 @@ export class Sequencer {
       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.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})`,
+          `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`);
@@ -550,11 +481,16 @@ export class Sequencer {
       // 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,
       };
     } finally {
@@ -566,7 +502,8 @@ export class Sequencer {
           await publicProcessorFork.close();
           await orchestratorFork.close();
         } catch (err) {
-          this.log.error(`Error closing forks`, 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);
     }
@@ -605,7 +542,7 @@ export class Sequencer {
 
     try {
       const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables, historicalHeader);
-      const { block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
+      const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
       // block being published before ours instead of just waiting on our block
@@ -647,16 +584,19 @@ export class Sequencer {
       const proofQuote = await proofQuotePromise;
 
       await this.publishL2Block(block, attestations, txHashes, proofQuote);
-      this.metrics.recordPublishedBlock(workDuration);
+      this.metrics.recordPublishedBlock(workDuration, publicGas.l2Gas);
+      const duration = Math.ceil(workDuration);
+      const manaPerSecond = Math.ceil((publicGas.l2Gas * 1000) / duration);
       this.log.info(
-        `Published block ${block.number} with ${numTxs} txs and ${numMsgs} messages in ${Math.ceil(workDuration)}ms`,
+        `Published block ${block.number} with ${numTxs} txs and ${numMsgs} messages in ${duration} ms at ${manaPerSecond} mana/s`,
         {
+          publicGas,
           blockNumber: block.number,
           blockHash: blockHash,
           slot,
           txCount: txHashes.length,
           msgCount: numMsgs,
-          duration: Math.ceil(workDuration),
+          duration,
           submitter: this.publisher.getSenderAddress().toString(),
         },
       );
@@ -707,7 +647,15 @@ export class Sequencer {
     this.log.debug('Broadcasting block proposal to validators');
     this.validatorClient.broadcastBlockProposal(proposal);
 
-    const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations);
+    const attestationTimeAllowed = this.enforceTimeTable
+      ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_BLOCK)!
+      : this.aztecSlotDuration;
+    const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
+    const attestations = await this.validatorClient.collectAttestations(
+      proposal,
+      numberOfRequiredAttestations,
+      attestationDeadline,
+    );
 
     // note: the smart contract requires that the signatures are provided in the order of the committee
     return orderAttestations(attestations, committee);
@@ -772,7 +720,13 @@ export class Sequencer {
     // Publishes new block to the network and awaits the tx to be mined
     this.setState(SequencerState.PUBLISHING_BLOCK, block.header.globalVariables.slotNumber.toBigInt());
 
-    const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote);
+    // Time out tx at the end of the slot
+    const slot = block.header.globalVariables.slotNumber.toNumber();
+    const txTimeoutAt = new Date((this.getSlotStartTimestamp(slot) + this.aztecSlotDuration) * 1000);
+
+    const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote, {
+      txTimeoutAt,
+    });
     if (!publishedL2Block) {
       throw new Error(`Failed to publish block ${block.number}`);
     }

package/src/sequencer/timetable.ts

@@ -0,0 +1,123 @@
+import { createLogger } from '@aztec/aztec.js';
+
+import { type SequencerMetrics } from './metrics.js';
+import { SequencerState } from './utils.js';
+
+export class SequencerTimetable {
+  /** How late into the slot can we be to start working */
+  public readonly initialTime = 3;
+
+  /** How long it takes to get ready to start building */
+  public readonly blockPrepareTime = 1;
+
+  /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */
+  public readonly attestationPropagationTime = 2;
+
+  /** How much time we spend validating and processing a block after building it, and assembling the proposal to send to attestors */
+  public readonly blockValidationTime = 1;
+
+  /**
+   * How long it takes to get a published block into L1. L1 builders typically accept txs up to 4 seconds into their slot,
+   * but we'll timeout sooner to give it more time to propagate (remember we also have blobs!). Still, when working in anvil,
+   * we can just post in the very last second of the L1 slot and still expect the tx to be accepted.
+   */
+  public readonly l1PublishingTime;
+
+  constructor(
+    private readonly ethereumSlotDuration: number,
+    private readonly aztecSlotDuration: number,
+    private readonly maxL1TxInclusionTimeIntoSlot: number,
+    private readonly enforce: boolean = true,
+    private readonly metrics?: SequencerMetrics,
+    private readonly log = createLogger('sequencer:timetable'),
+  ) {
+    this.l1PublishingTime = this.ethereumSlotDuration - this.maxL1TxInclusionTimeIntoSlot;
+  }
+
+  private get afterBlockBuildingTimeNeededWithoutReexec() {
+    return this.blockValidationTime + this.attestationPropagationTime * 2 + this.l1PublishingTime;
+  }
+
+  public getBlockProposalExecTimeEnd(secondsIntoSlot: number): number {
+    // We are N seconds into the slot. We need to account for `afterBlockBuildingTimeNeededWithoutReexec` seconds,
+    // send then split the remaining time between the re-execution and the block building.
+    const maxAllowed = this.aztecSlotDuration - this.afterBlockBuildingTimeNeededWithoutReexec;
+    const available = maxAllowed - secondsIntoSlot;
+    const executionTimeEnd = secondsIntoSlot + available / 2;
+    this.log.debug(`Block proposal execution time deadline is ${executionTimeEnd}`, {
+      secondsIntoSlot,
+      maxAllowed,
+      available,
+      executionTimeEnd,
+    });
+    return executionTimeEnd;
+  }
+
+  private get afterBlockReexecTimeNeeded() {
+    return this.attestationPropagationTime + this.l1PublishingTime;
+  }
+
+  public getValidatorReexecTimeEnd(secondsIntoSlot: number): number {
+    // We need to leave for `afterBlockReexecTimeNeeded` seconds available.
+    const validationTimeEnd = this.aztecSlotDuration - this.afterBlockReexecTimeNeeded;
+    this.log.debug(`Validator re-execution time deadline is ${validationTimeEnd}`, {
+      secondsIntoSlot,
+      validationTimeEnd,
+    });
+    return validationTimeEnd;
+  }
+
+  public getMaxAllowedTime(state: SequencerState): number | undefined {
+    switch (state) {
+      case SequencerState.STOPPED:
+      case SequencerState.IDLE:
+      case SequencerState.SYNCHRONIZING:
+      case SequencerState.PROPOSER_CHECK:
+        return; // We don't really care about times for this states
+      case SequencerState.INITIALIZING_PROPOSAL:
+        return this.initialTime;
+      case SequencerState.CREATING_BLOCK:
+        return this.initialTime + this.blockPrepareTime;
+      case SequencerState.COLLECTING_ATTESTATIONS:
+        return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.attestationPropagationTime;
+      case SequencerState.PUBLISHING_BLOCK:
+        return this.aztecSlotDuration - this.l1PublishingTime;
+      default: {
+        const _exhaustiveCheck: never = state;
+        throw new Error(`Unexpected state: ${state}`);
+      }
+    }
+  }
+
+  public assertTimeLeft(newState: SequencerState, secondsIntoSlot: number) {
+    if (!this.enforce) {
+      return;
+    }
+
+    const maxAllowedTime = this.getMaxAllowedTime(newState);
+    if (maxAllowedTime === undefined) {
+      return;
+    }
+
+    const bufferSeconds = maxAllowedTime - secondsIntoSlot;
+    if (bufferSeconds < 0) {
+      throw new SequencerTooSlowError(newState, maxAllowedTime, secondsIntoSlot);
+    }
+
+    this.metrics?.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), newState);
+    this.log.trace(`Enough time to transition to ${newState}`, { maxAllowedTime, secondsIntoSlot });
+  }
+}
+
+export class SequencerTooSlowError extends Error {
+  constructor(
+    public readonly proposedState: SequencerState,
+    public readonly maxAllowedTime: number,
+    public readonly currentTime: number,
+  ) {
+    super(
+      `Too far into slot for ${proposedState} (time into slot ${currentTime}s greater than ${maxAllowedTime}s allowance)`,
+    );
+    this.name = 'SequencerTooSlowError';
+  }
+}

package/src/slasher/factory.ts

@@ -4,8 +4,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { type AztecKVStore } from '@aztec/kv-store';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { createStore } from '@aztec/kv-store/lmdb';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { SlasherClient } from './slasher_client.js';
 import { type SlasherConfig } from './slasher_client.js';
@@ -13,7 +12,7 @@ import { type SlasherConfig } from './slasher_client.js';
 export const createSlasherClient = async (
   _config: SlasherConfig & DataStoreConfig & L1ContractsConfig & L1ReaderConfig,
   l2BlockSource: L2BlockSource,
-  telemetry: TelemetryClient = new NoopTelemetryClient(),
+  telemetry: TelemetryClient = getTelemetryClient(),
   deps: { store?: AztecKVStore } = {},
 ) => {
   const config = { ..._config };

package/src/slasher/slasher_client.ts

@@ -12,8 +12,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { type AztecKVStore, type AztecMap, type AztecSingleton } from '@aztec/kv-store';
 import { SlashFactoryAbi } from '@aztec/l1-artifacts';
-import { type TelemetryClient, WithTracer } from '@aztec/telemetry-client';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+import { type TelemetryClient, WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
 
 import {
   type Chain,
@@ -113,7 +112,7 @@ export class SlasherClient extends WithTracer {
     private config: SlasherConfig & L1ContractsConfig & L1ReaderConfig,
     private store: AztecKVStore,
     private l2BlockSource: L2BlockSource,
-    telemetry: TelemetryClient = new NoopTelemetryClient(),
+    telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('slasher'),
   ) {
     super(telemetry, 'slasher');

package/src/test/index.ts

@@ -0,0 +1,22 @@
+import { type PublicProcessorFactory } from '@aztec/simulator/server';
+
+import { SequencerClient } from '../client/sequencer-client.js';
+import { type L1Publisher } from '../publisher/l1-publisher.js';
+import { Sequencer } from '../sequencer/sequencer.js';
+import { type SequencerTimetable } from '../sequencer/timetable.js';
+
+class TestSequencer_ extends Sequencer {
+  public override publicProcessorFactory!: PublicProcessorFactory;
+  public override timetable!: SequencerTimetable;
+  public override publisher!: L1Publisher;
+}
+
+export type TestSequencer = TestSequencer_;
+
+class TestSequencerClient_ extends SequencerClient {
+  public override sequencer!: TestSequencer;
+}
+
+export type TestSequencerClient = TestSequencerClient_;
+
+export * from './test-l1-publisher.js';

package/src/{publisher → test}/test-l1-publisher.ts

@@ -3,7 +3,7 @@ import { type Delayer, withDelayer } from '@aztec/ethereum/test';
 
 import { type Chain, type HttpTransport, type PrivateKeyAccount, type WalletClient } from 'viem';
 
-import { L1Publisher } from './l1-publisher.js';
+import { L1Publisher } from '../publisher/l1-publisher.js';
 
 export class TestL1Publisher extends L1Publisher {
   public delayer: Delayer | undefined;

package/src/tx_validator/archive_cache.ts

@@ -0,0 +1,27 @@
+import { MerkleTreeId, type MerkleTreeReadOperations } from '@aztec/circuit-types';
+import { type Fr } from '@aztec/circuits.js';
+import { type ArchiveSource } from '@aztec/p2p';
+
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class ArchiveCache implements ArchiveSource {
+  archives: Map<string, bigint>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.archives = new Map<string, bigint>();
+  }
+
+  public async getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]> {
+    const toCheckDb = archives.filter(n => !this.archives.has(n.toString()));
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
+    dbHits.forEach((x, index) => {
+      if (x !== undefined) {
+        this.archives.set(toCheckDb[index].toString(), x);
+      }
+    });
+
+    return archives.map(n => this.archives.get(n.toString()));
+  }
+}

package/src/tx_validator/gas_validator.ts

@@ -1,7 +1,7 @@
 import { type Tx, TxExecutionPhase, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
-import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator';
+import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator/server';
 
 /** Provides a view into public contract state */
 export interface PublicStateSource {

package/src/tx_validator/phases_validator.ts

@@ -8,7 +8,7 @@ import {
 } from '@aztec/circuit-types';
 import { type ContractDataSource } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
-import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator';
+import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator/server';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_phases');