@aztec/sequencer-client 0.70.0 → 0.72.1

package/src/sequencer/sequencer.ts

@@ -33,11 +33,9 @@ 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/server';
-import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { type ValidatorClient } from '@aztec/validator-client';
 
-import assert from 'assert';
-
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type L1Publisher, VoteType } from '../publisher/l1-publisher.js';
 import { type SlasherClient } from '../slasher/slasher_client.js';
@@ -45,24 +43,11 @@ import { createValidatorsForBlockBuilding } from '../tx_validator/tx_validator_f
 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'>;
 
 /**
@@ -78,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;
@@ -86,17 +71,13 @@ export class Sequencer {
   private state = SequencerState.STOPPED;
   private allowedInSetup: AllowedElement[] = getDefaultAllowedSetupFunctions();
   private maxBlockSizeInBytes: number = 1024 * 1024;
-  private maxBlockGas: Gas = new Gas(10e9, 10e9);
-  protected processTxTime: number = 12;
-  private attestationPropagationTime: number = 2;
+  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(
@@ -113,8 +94,8 @@ export class Sequencer {
     protected contractDataSource: ContractDataSource,
     protected l1Constants: SequencerRollupConstants,
     protected dateProvider: DateProvider,
-    telemetry: TelemetryClient,
     protected config: SequencerConfig = {},
+    telemetry: TelemetryClient = getTelemetryClient(),
     protected log = createLogger('sequencer'),
   ) {
     this.updateConfig(config);
@@ -145,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);
@@ -182,78 +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 proposals and attestations to travel across the p2p layer (one-way)
-    const attestationPropagationTime = 2;
-    this.attestationPropagationTime = attestationPropagationTime;
-
-    // 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.
-    const l1PublishingTime = this.l1Constants.ethereumSlotDuration - this.maxL1TxInclusionTimeIntoSlot;
-
-    // How much time we spend validating and processing a block after building it,
-    // and assembling the proposal to send to attestors
-    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 -
-      blockValidationTime -
-      2 * attestationPropagationTime -
-      l1PublishingTime;
-
-    // Check that we actually have time left for processing txs
-    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;
-
-    // Sanity check
-    const totalSlotTime =
-      initialTime + // Archiver, world-state, and p2p sync
-      blockPrepareTime + // Setup globals, initial checks, etc
-      processTxsTime + // Processing public txs for building the block
-      blockValidationTime + // Validating the block produced
-      attestationPropagationTime + // Propagating the block proposal to validators
-      processTxsTime + // Validators run public txs before signing
-      attestationPropagationTime + // Attestations fly back to the proposer
-      l1PublishingTime; // The publish tx sits on the L1 mempool waiting to be picked up
-
-    assert(
-      totalSlotTime === this.aztecSlotDuration,
-      `Computed total slot time does not match slot duration: ${totalSlotTime}s`,
+    this.timetable = new SequencerTimetable(
+      this.l1Constants.ethereumSlotDuration,
+      this.aztecSlotDuration,
+      this.maxL1TxInclusionTimeIntoSlot,
+      this.enforceTimeTable,
+      this.metrics,
+      this.log,
     );
-
-    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.log.verbose(`Sequencer timetable updated`, { enforceTimeTable: this.enforceTimeTable });
   }
 
   /**
@@ -318,20 +236,15 @@ export class Sequencer {
     this.setState(SequencerState.PROPOSER_CHECK, 0n);
 
     const chainTip = await this.l2BlockSource.getBlock(-1);
-    const historicalHeader = chainTip?.header;
 
-    const newBlockNumber =
-      (historicalHeader === undefined
-        ? await this.l2BlockSource.getBlockNumber()
-        : Number(historicalHeader.globalVariables.blockNumber.toBigInt())) + 1;
+    const newBlockNumber = (chainTip?.header.globalVariables.blockNumber.toNumber() ?? 0) + 1;
 
     // If we cannot find a tip archive, assume genesis.
-    const chainTipArchive =
-      chainTip == undefined ? new Fr(GENESIS_ARCHIVE_ROOT).toBuffer() : chainTip?.archive.root.toBuffer();
+    const chainTipArchive = chainTip?.archive.root ?? new Fr(GENESIS_ARCHIVE_ROOT);
 
     let slot: bigint;
     try {
-      slot = await this.mayProposeBlock(chainTipArchive, BigInt(newBlockNumber));
+      slot = await this.mayProposeBlock(chainTipArchive.toBuffer(), BigInt(newBlockNumber));
     } catch (err) {
       this.log.debug(`Cannot propose for block ${newBlockNumber}`);
       return;
@@ -349,8 +262,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,
       });
@@ -360,7 +273,7 @@ export class Sequencer {
 
     this.setState(SequencerState.INITIALIZING_PROPOSAL, slot);
     this.log.verbose(`Preparing proposal for block ${newBlockNumber} at slot ${slot}`, {
-      chainTipArchive: new Fr(chainTipArchive),
+      chainTipArchive,
       blockNumber: newBlockNumber,
       slot,
     });
@@ -371,7 +284,7 @@ export class Sequencer {
 
     // If I created a "partial" header here that should make our job much easier.
     const proposalHeader = new BlockHeader(
-      new AppendOnlyTreeSnapshot(Fr.fromBuffer(chainTipArchive), 1),
+      new AppendOnlyTreeSnapshot(chainTipArchive, 1),
       ContentCommitment.empty(),
       StateReference.empty(),
       newGlobalVariables,
@@ -384,9 +297,12 @@ export class Sequencer {
       // @note  It is very important that the following function will FAIL and not just return early
       //        if it have made any state changes. If not, we won't rollback the state, and you will
       //        be in for a world of pain.
-      await this.buildBlockAndAttemptToPublish(pendingTxs, proposalHeader, historicalHeader);
+      await this.buildBlockAndAttemptToPublish(pendingTxs, proposalHeader);
     } catch (err) {
       this.log.error(`Error assembling block`, err, { blockNumber: newBlockNumber, slot });
+
+      // If the block failed to build, we might still want to claim the proving rights
+      await this.claimEpochProofRightIfAvailable(slot);
     }
     this.setState(SequencerState.IDLE, 0n);
   }
@@ -427,29 +343,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.
@@ -465,9 +358,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;
   }
@@ -482,17 +373,16 @@ 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,
     opts: { validateOnly?: boolean } = {},
   ) {
-    const blockNumber = newGlobalVariables.blockNumber.toBigInt();
+    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(blockNumber);
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(blockNumber));
     const msgCount = l1ToL2Messages.length;
 
     this.log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
@@ -503,31 +393,27 @@ export class Sequencer {
     });
 
     // Sync to the previous block at least
-    await this.worldState.syncImmediate(newGlobalVariables.blockNumber.toNumber() - 1);
-    this.log.debug(`Synced to previous block ${newGlobalVariables.blockNumber.toNumber() - 1}`);
+    await this.worldState.syncImmediate(blockNumber - 1);
+    this.log.debug(`Synced to previous block ${blockNumber - 1}`);
 
     // NB: separating the dbs because both should update the state
     const publicProcessorFork = await this.worldState.fork();
     const orchestratorFork = await this.worldState.fork();
 
+    const previousBlockHeader =
+      (await this.l2BlockSource.getBlock(blockNumber - 1))?.header ?? orchestratorFork.getInitialHeader();
+
     try {
-      const processor = this.publicProcessorFactory.create(
-        publicProcessorFork,
-        historicalHeader,
-        newGlobalVariables,
-        true,
-      );
+      const processor = this.publicProcessorFactory.create(publicProcessorFork, newGlobalVariables, true);
       const blockBuildingTimer = new Timer();
       const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
-      await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages);
+      await blockBuilder.startNewBlock(newGlobalVariables, l1ToL2Messages, previousBlockHeader);
 
-      // When building a block as a proposer, we set the deadline for tx processing to the start of the
-      // CREATING_BLOCK phase, plus the expected time for tx processing. When validating, we start counting
-      // the time for tx processing from the start of the COLLECTING_ATTESTATIONS phase plus the attestation
-      // propagation time. See the comments in setTimeTable for more details.
+      // Deadline for processing depends on whether we're proposing a block
+      const secondsIntoSlot = this.getSecondsIntoSlot(slot);
       const processingEndTimeWithinSlot = opts.validateOnly
-        ? this.timeTable[SequencerState.COLLECTING_ATTESTATIONS] + this.attestationPropagationTime + this.processTxTime
-        : this.timeTable[SequencerState.CREATING_BLOCK] + this.processTxTime;
+        ? this.timetable.getValidatorReexecTimeEnd(secondsIntoSlot)
+        : this.timetable.getBlockProposalExecTimeEnd(secondsIntoSlot);
 
       // Deadline is only set if enforceTimeTable is enabled.
       const deadline = this.enforceTimeTable
@@ -552,7 +438,12 @@ export class Sequencer {
       // 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),
       );
@@ -566,11 +457,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`);
@@ -606,7 +497,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);
     }
@@ -620,16 +512,11 @@ export class Sequencer {
    *
    * @param pendingTxs - Iterable of pending transactions to construct the block from
    * @param proposalHeader - The partial header constructed for the proposal
-   * @param historicalHeader - The historical header of the parent
    */
-  @trackSpan('Sequencer.buildBlockAndAttemptToPublish', (_validTxs, proposalHeader, _historicalHeader) => ({
+  @trackSpan('Sequencer.buildBlockAndAttemptToPublish', (_validTxs, proposalHeader) => ({
     [Attributes.BLOCK_NUMBER]: proposalHeader.globalVariables.blockNumber.toNumber(),
   }))
-  private async buildBlockAndAttemptToPublish(
-    pendingTxs: Iterable<Tx>,
-    proposalHeader: BlockHeader,
-    historicalHeader: BlockHeader | undefined,
-  ): Promise<void> {
+  private async buildBlockAndAttemptToPublish(pendingTxs: Iterable<Tx>, proposalHeader: BlockHeader): Promise<void> {
     await this.publisher.validateBlockForSubmission(proposalHeader);
 
     const newGlobalVariables = proposalHeader.globalVariables;
@@ -644,7 +531,7 @@ export class Sequencer {
     const proofQuotePromise = this.createProofClaimForPreviousEpoch(slot);
 
     try {
-      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables, historicalHeader);
+      const buildBlockRes = await this.buildBlock(pendingTxs, newGlobalVariables);
       const { publicGas, block, publicProcessorDuration, numTxs, numMsgs, blockBuildingTimer } = buildBlockRes;
 
       // TODO(@PhilWindle) We should probably periodically check for things like another
@@ -743,14 +630,22 @@ export class Sequencer {
     this.log.debug('Creating block proposal for validators');
     const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
     if (!proposal) {
-      this.log.warn(`Failed to create block proposal, skipping collecting attestations`);
-      return undefined;
+      const msg = `Failed to create block proposal`;
+      throw new Error(msg);
     }
 
     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);

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

@@ -3,12 +3,11 @@ 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 SequencerState } from '../sequencer/utils.js';
+import { type SequencerTimetable } from '../sequencer/timetable.js';
 
 class TestSequencer_ extends Sequencer {
   public override publicProcessorFactory!: PublicProcessorFactory;
-  public override timeTable!: Record<SequencerState, number>;
-  public override processTxTime!: number;
+  public override timetable!: SequencerTimetable;
   public override publisher!: L1Publisher;
 }
 

package/src/tx_validator/gas_validator.ts

@@ -1,5 +1,6 @@
 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 { type AztecAddress, Fr, FunctionSelector, type GasFees } from '@aztec/circuits.js';
+import { U128 } from '@aztec/foundation/abi';
 import { createLogger } from '@aztec/foundation/log';
 import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator/server';
 
@@ -34,6 +35,12 @@ export class GasTxValidator implements TxValidator<Tx> {
     return this.#validateTxFee(tx);
   }
 
+  /**
+   * Check whether the tx's max fees are valid for the current block, and skip if not.
+   * We skip instead of invalidating since the tx may become elligible later.
+   * Note that circuits check max fees even if fee payer is unset, so we
+   * keep this validation even if the tx does not pay fees.
+   */
   #shouldSkip(tx: Tx): boolean {
     const gasSettings = tx.data.constants.txContext.gasSettings;
 
@@ -78,12 +85,17 @@ export class GasTxValidator implements TxValidator<Tx> {
         fn.callContext.msgSender.equals(this.#feeJuiceAddress) &&
         fn.args.length > 2 &&
         // Public functions get routed through the dispatch function, whose first argument is the target function selector.
-        fn.args[0].equals(FunctionSelector.fromSignature('_increase_public_balance((Field),Field)').toField()) &&
+        fn.args[0].equals(
+          FunctionSelector.fromSignature('_increase_public_balance((Field),(Field,Field))').toField(),
+        ) &&
         fn.args[1].equals(feePayer.toField()) &&
         !fn.callContext.isStaticCall,
     );
 
-    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
+    // `amount` in the claim function call arguments occupies 2 fields as it is represented as U128.
+    const balance = claimFunctionCall
+      ? initialBalance.add(new Fr(U128.fromFields(claimFunctionCall.args.slice(2, 4)).toInteger()))
+      : initialBalance;
     if (balance.lt(feeLimit)) {
       this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,