@aztec/sequencer-client 5.0.0-private.20260318 → 5.0.0-rc.1

package/src/sequencer/types.ts

@@ -2,5 +2,5 @@ import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 
 export type SequencerRollupConstants = Pick<
   L1RollupConstants,
-  'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration' | 'rollupManaLimit'
+  'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration' | 'rollupManaLimit' | 'epochDuration'
 >;

package/src/test/index.ts

@@ -1,16 +1,16 @@
 import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import type { PublisherManager } from '@aztec/ethereum/publisher-manager';
 import type { PublicProcessorFactory } from '@aztec/simulator/server';
+import type { ProposerTimetable } from '@aztec/stdlib/timetable';
 import type { FullNodeCheckpointsBuilder, ValidatorClient } from '@aztec/validator-client';
 
 import { SequencerClient } from '../client/sequencer-client.js';
 import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
 import { Sequencer } from '../sequencer/sequencer.js';
-import type { SequencerTimetable } from '../sequencer/timetable.js';
 
 class TestSequencer_ extends Sequencer {
   declare public publicProcessorFactory: PublicProcessorFactory;
-  declare public timetable: SequencerTimetable;
+  declare public timetable: ProposerTimetable;
   declare public publisherFactory: SequencerPublisherFactory;
   declare public validatorClient: ValidatorClient;
   declare public checkpointsBuilder: FullNodeCheckpointsBuilder;

package/src/test/mock_checkpoint_builder.ts

@@ -4,11 +4,11 @@ import { unfreeze } from '@aztec/foundation/types';
 import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type {
+  BlockBuilderOptions,
   FullNodeBlockBuilderConfig,
   ICheckpointBlockBuilder,
   ICheckpointsBuilder,
   MerkleTreeWriteOperations,
-  PublicProcessorLimits,
 } from '@aztec/stdlib/interfaces/server';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
@@ -32,7 +32,7 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
   public buildBlockCalls: Array<{
     blockNumber: BlockNumber;
     timestamp: bigint;
-    opts: PublicProcessorLimits & { minValidTxs?: number };
+    opts: BlockBuilderOptions;
   }> = [];
   /** Track all consumed transaction hashes across buildBlock calls */
   public consumedTxHashes: Set<string> = new Set();
@@ -74,7 +74,7 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
     pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
     blockNumber: BlockNumber,
     timestamp: bigint,
-    opts: PublicProcessorLimits & { minValidTxs?: number },
+    opts: BlockBuilderOptions,
   ): Promise<BuildBlockInCheckpointResult> {
     this.buildBlockCalls.push({ blockNumber, timestamp, opts });
 

package/src/test/utils.ts

@@ -8,9 +8,22 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import type { P2P } from '@aztec/p2p';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { DEFAULT_BLOCK_DURATION_MS } from '@aztec/stdlib/config';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { BlockProposal, CheckpointAttestation, CheckpointProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
-import { makeAppendOnlyTreeSnapshot, mockTxForRollup } from '@aztec/stdlib/testing';
+import {
+  TEST_COORDINATION_SIGNATURE_CONTEXT,
+  makeAppendOnlyTreeSnapshot,
+  mockTxForRollup,
+} from '@aztec/stdlib/testing';
+import {
+  DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+  DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+  DEFAULT_MIN_BLOCK_DURATION,
+  DEFAULT_P2P_PROPAGATION_TIME,
+  ProposerTimetable,
+} from '@aztec/stdlib/timetable';
 import { BlockHeader, GlobalVariables, type Tx, makeProcessedTxFromPrivateOnlyTx } from '@aztec/stdlib/tx';
 
 import type { MockProxy } from 'jest-mock-extended';
@@ -18,6 +31,28 @@ import type { MockProxy } from 'jest-mock-extended';
 // Re-export mock classes from their dedicated file
 export { MockCheckpointBuilder, MockCheckpointsBuilder } from './mock_checkpoint_builder.js';
 
+/**
+ * Builds a {@link ProposerTimetable} for tests from a millisecond block duration and optional budgets,
+ * filling unset budgets with the shared `DEFAULT_*` values the sequencer config layer applies. Mirrors how
+ * the sequencer constructs its timetable so tests exercise the same budget resolution.
+ */
+export function makeProposerTimetable(opts: {
+  l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>;
+  blockDurationMs?: number;
+  minBlockDuration?: number;
+  p2pPropagationTime?: number;
+  checkpointProposalPrepareTime?: number;
+}): ProposerTimetable {
+  return new ProposerTimetable({
+    l1Constants: opts.l1Constants,
+    blockDuration: (opts.blockDurationMs ?? DEFAULT_BLOCK_DURATION_MS) / 1000,
+    minBlockDuration: opts.minBlockDuration ?? DEFAULT_MIN_BLOCK_DURATION,
+    p2pPropagationTime: opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME,
+    checkpointProposalPrepareTime: opts.checkpointProposalPrepareTime ?? DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+    checkpointProposalInitTime: DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+  });
+}
+
 /**
  * Creates a mock transaction with a specific seed for deterministic testing
  */
@@ -109,6 +144,7 @@ export function createBlockProposal(block: L2Block, signature: Signature): Block
     block.archive.root,
     txHashes,
     signature,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
   );
 }
 
@@ -123,12 +159,19 @@ export function createCheckpointProposal(
 ): CheckpointProposal {
   const txHashes = block.body.txEffects.map(tx => tx.txHash);
   const checkpointHeader = createCheckpointHeaderFromBlock(block);
-  return new CheckpointProposal(checkpointHeader, block.archive.root, feeAssetPriceModifier, checkpointSignature, {
-    blockHeader: block.header,
-    indexWithinCheckpoint: block.indexWithinCheckpoint,
-    txHashes,
-    signature: blockSignature ?? checkpointSignature, // Use checkpoint signature as block signature if not provided
-  });
+  return new CheckpointProposal(
+    checkpointHeader,
+    block.archive.root,
+    feeAssetPriceModifier,
+    checkpointSignature,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
+    {
+      blockHeader: block.header,
+      indexWithinCheckpoint: block.indexWithinCheckpoint,
+      txHashes,
+      signature: blockSignature ?? checkpointSignature, // Use checkpoint signature as block signature if not provided
+    },
+  );
 }
 
 /**
@@ -143,10 +186,16 @@ export function createCheckpointAttestation(
   feeAssetPriceModifier: bigint = 0n,
 ): CheckpointAttestation {
   const checkpointHeader = createCheckpointHeaderFromBlock(block);
-  const payload = new ConsensusPayload(checkpointHeader, block.archive.root, feeAssetPriceModifier);
+  const payload = new ConsensusPayload(
+    checkpointHeader,
+    block.archive.root,
+    feeAssetPriceModifier,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
+  );
   const attestation = new CheckpointAttestation(payload, signature, signature);
-  // Set sender directly for testing (bypasses signature recovery)
-  (attestation as any).sender = sender;
+  // Bypass signature recovery for testing since we use random signatures
+  (attestation as any).getSender = () => sender;
+  (attestation as any).getProposer = () => sender;
   return attestation;
 }
 

package/dest/sequencer/timetable.d.ts

@@ -1,88 +0,0 @@
-import type { Logger } from '@aztec/foundation/log';
-import type { SequencerMetrics } from './metrics.js';
-import { SequencerState } from './utils.js';
-export declare class SequencerTimetable {
-    private readonly metrics?;
-    private readonly log?;
-    /**
-     * How late into the slot can we be to start working. Computed as the total time needed for assembling and publishing a block,
-     * assuming an execution time equal to `minExecutionTime`, subtracted from the slot duration. This means that, if the proposer
-     * starts building at this time, and all times hold, it will have at least `minExecutionTime` to execute txs for the block.
-     */
-    readonly initializeDeadline: number;
-    /**
-     * Fixed time offset (in seconds) when the first sub-slot starts, used as baseline for all block deadlines.
-     * This is an estimate of how long initialization (sync + proposer check) typically takes.
-     * If actual initialization takes longer/shorter, blocks just get less/more time accordingly.
-     */
-    readonly initializationOffset: number;
-    /**
-     * Total time needed to finalize and publish a checkpoint, including:
-     * - Assembling the checkpoint
-     * - Round-trip p2p propagation for the checkpoint proposal and its corresponding attestations
-     * - Publishing to L1
-     */
-    readonly checkpointFinalizationTime: number;
-    /**
-     * 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.
-     */
-    readonly l1PublishingTime: number;
-    /**
-     * What's the minimum time we want to leave available for execution and reexecution (used to derive init deadline)
-     * Defaults to half of the block duration if set, otherwise a constant.
-     */
-    readonly minExecutionTime: number;
-    /** How long it takes to get ready to start building */
-    readonly checkpointInitializationTime: number;
-    /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */
-    readonly p2pPropagationTime: number;
-    /** How much time we spend assembling a checkpoint after building the last block */
-    readonly checkpointAssembleTime: number;
-    /** Ethereum slot duration in seconds */
-    readonly ethereumSlotDuration: number;
-    /** Aztec slot duration in seconds (must be multiple of ethereum slot duration) */
-    readonly aztecSlotDuration: number;
-    /** Whether assertTimeLeft will throw if not enough time. */
-    readonly enforce: boolean;
-    /** Duration per block when building multiple blocks per slot (undefined = single block per slot) */
-    readonly blockDuration: number | undefined;
-    /** Maximum number of blocks that can be built in this slot configuration */
-    readonly maxNumberOfBlocks: number;
-    constructor(opts: {
-        ethereumSlotDuration: number;
-        aztecSlotDuration: number;
-        l1PublishingTime: number;
-        p2pPropagationTime?: number;
-        blockDurationMs?: number;
-        enforce: boolean;
-    }, metrics?: SequencerMetrics | undefined, log?: Logger | undefined);
-    getMaxAllowedTime(state: Extract<SequencerState, SequencerState.STOPPED | SequencerState.IDLE | SequencerState.SYNCHRONIZING>): undefined;
-    getMaxAllowedTime(state: Exclude<SequencerState, SequencerState.STOPPED | SequencerState.IDLE | SequencerState.SYNCHRONIZING>): number;
-    getMaxAllowedTime(state: SequencerState): number | undefined;
-    assertTimeLeft(newState: SequencerState, secondsIntoSlot: number): void;
-    /**
-     * Determines if we can start building the next block and returns its deadline.
-     *
-     * The timetable divides the slot into fixed sub-slots. This method finds the next
-     * available sub-slot that has enough time remaining to build a block.
-     *
-     * @param secondsIntoSlot - Current time (seconds into the slot)
-     * @returns Object with canStart flag, deadline, and whether this is the last block
-     */
-    canStartNextBlock(secondsIntoSlot: number): {
-        canStart: true;
-        deadline: undefined;
-        isLastBlock: true;
-    } | {
-        canStart: false;
-        deadline: undefined;
-        isLastBlock: false;
-    } | {
-        canStart: boolean;
-        deadline: number;
-        isLastBlock: boolean;
-    };
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/sequencer/timetable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timetable.d.ts","sourceRoot":"","sources":["../../src/sequencer/timetable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AASpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,qBAAa,kBAAkB;IAqE3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC;IArEvB;;;;OAIG;IACH,SAAgB,kBAAkB,EAAE,MAAM,CAAC;IAE3C;;;;OAIG;IACH,SAAgB,oBAAoB,EAAE,MAAM,CAAC;IAE7C;;;;;OAKG;IACH,SAAgB,0BAA0B,EAAE,MAAM,CAAC;IAEnD;;;;OAIG;IACH,SAAgB,gBAAgB,EAAE,MAAM,CAAC;IAEzC;;;OAGG;IACH,SAAgB,gBAAgB,EAAE,MAAM,CAAsB;IAE9D,uDAAuD;IACvD,SAAgB,4BAA4B,EAAE,MAAM,CAAkC;IAEtF,mGAAmG;IACnG,SAAgB,kBAAkB,EAAE,MAAM,CAAC;IAE3C,mFAAmF;IACnF,SAAgB,sBAAsB,EAAE,MAAM,CAA4B;IAE1E,wCAAwC;IACxC,SAAgB,oBAAoB,EAAE,MAAM,CAAC;IAE7C,kFAAkF;IAClF,SAAgB,iBAAiB,EAAE,MAAM,CAAC;IAE1C,4DAA4D;IAC5D,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC,oGAAoG;IACpG,SAAgB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAElD,4EAA4E;IAC5E,SAAgB,iBAAiB,EAAE,MAAM,CAAC;IAE1C,YACE,IAAI,EAAE;QACJ,oBAAoB,EAAE,MAAM,CAAC;QAC7B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,gBAAgB,EAAE,MAAM,CAAC;QACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,OAAO,EAAE,OAAO,CAAC;KAClB,EACgB,OAAO,CAAC,8BAAkB,EAC1B,GAAG,CAAC,oBAAQ,EA2E9B;IAEM,iBAAiB,CACtB,KAAK,EAAE,OAAO,CAAC,cAAc,EAAE,cAAc,CAAC,OAAO,GAAG,cAAc,CAAC,IAAI,GAAG,cAAc,CAAC,aAAa,CAAC,GAC1G,SAAS,CAAC;IACN,iBAAiB,CACtB,KAAK,EAAE,OAAO,CAAC,cAAc,EAAE,cAAc,CAAC,OAAO,GAAG,cAAc,CAAC,IAAI,GAAG,cAAc,CAAC,aAAa,CAAC,GAC1G,MAAM,CAAC;IACH,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAAC;IA2B7D,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,QAiBtE;IAED;;;;;;;;OAQG;IACI,iBAAiB,CACtB,eAAe,EAAE,MAAM,GAErB;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,SAAS,CAAC;QAAC,WAAW,EAAE,IAAI,CAAA;KAAE,GAC1D;QAAE,QAAQ,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,SAAS,CAAC;QAAC,WAAW,EAAE,KAAK,CAAA;KAAE,GAC5D;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE,CAwDhE;CACF"}

package/dest/sequencer/timetable.js

@@ -1,222 +0,0 @@
-import { CHECKPOINT_ASSEMBLE_TIME, CHECKPOINT_INITIALIZATION_TIME, DEFAULT_P2P_PROPAGATION_TIME, MIN_EXECUTION_TIME } from '@aztec/stdlib/timetable';
-import { SequencerTooSlowError } from './errors.js';
-import { SequencerState } from './utils.js';
-export class SequencerTimetable {
-    metrics;
-    log;
-    /**
-   * How late into the slot can we be to start working. Computed as the total time needed for assembling and publishing a block,
-   * assuming an execution time equal to `minExecutionTime`, subtracted from the slot duration. This means that, if the proposer
-   * starts building at this time, and all times hold, it will have at least `minExecutionTime` to execute txs for the block.
-   */ initializeDeadline;
-    /**
-   * Fixed time offset (in seconds) when the first sub-slot starts, used as baseline for all block deadlines.
-   * This is an estimate of how long initialization (sync + proposer check) typically takes.
-   * If actual initialization takes longer/shorter, blocks just get less/more time accordingly.
-   */ initializationOffset;
-    /**
-   * Total time needed to finalize and publish a checkpoint, including:
-   * - Assembling the checkpoint
-   * - Round-trip p2p propagation for the checkpoint proposal and its corresponding attestations
-   * - Publishing to L1
-   */ checkpointFinalizationTime;
-    /**
-   * 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.
-   */ l1PublishingTime;
-    /**
-   * What's the minimum time we want to leave available for execution and reexecution (used to derive init deadline)
-   * Defaults to half of the block duration if set, otherwise a constant.
-   */ minExecutionTime;
-    /** How long it takes to get ready to start building */ checkpointInitializationTime;
-    /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */ p2pPropagationTime;
-    /** How much time we spend assembling a checkpoint after building the last block */ checkpointAssembleTime;
-    /** Ethereum slot duration in seconds */ ethereumSlotDuration;
-    /** Aztec slot duration in seconds (must be multiple of ethereum slot duration) */ aztecSlotDuration;
-    /** Whether assertTimeLeft will throw if not enough time. */ enforce;
-    /** Duration per block when building multiple blocks per slot (undefined = single block per slot) */ blockDuration;
-    /** Maximum number of blocks that can be built in this slot configuration */ maxNumberOfBlocks;
-    constructor(opts, metrics, log){
-        this.metrics = metrics;
-        this.log = log;
-        this.minExecutionTime = MIN_EXECUTION_TIME;
-        this.checkpointInitializationTime = CHECKPOINT_INITIALIZATION_TIME;
-        this.checkpointAssembleTime = CHECKPOINT_ASSEMBLE_TIME;
-        this.ethereumSlotDuration = opts.ethereumSlotDuration;
-        this.aztecSlotDuration = opts.aztecSlotDuration;
-        this.l1PublishingTime = opts.l1PublishingTime;
-        this.p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
-        this.blockDuration = opts.blockDurationMs ? opts.blockDurationMs / 1000 : undefined;
-        this.enforce = opts.enforce;
-        // Assume zero-cost propagation time and faster runs in test environments where L1 slot duration is shortened
-        if (this.ethereumSlotDuration < 8) {
-            this.p2pPropagationTime = 0;
-            this.checkpointAssembleTime = 0.5;
-            this.checkpointInitializationTime = 0.5;
-            this.minExecutionTime = 1;
-        }
-        // Min execution time cannot be less than the block duration if set
-        if (this.blockDuration !== undefined && this.minExecutionTime > this.blockDuration) {
-            this.minExecutionTime = this.blockDuration;
-        }
-        // Calculate initialization offset - estimate of time needed for sync + proposer check
-        // This is the baseline for all sub-slot deadlines
-        this.initializationOffset = this.checkpointInitializationTime;
-        // Calculate total checkpoint finalization time (assembly + attestations + L1 publishing)
-        this.checkpointFinalizationTime = this.checkpointAssembleTime + this.p2pPropagationTime * 2 + // Round-trip propagation
-        this.l1PublishingTime; // L1 publishing
-        // Calculate maximum number of blocks that fit in this slot
-        if (!this.blockDuration) {
-            this.maxNumberOfBlocks = 1; // Single block per slot
-        } else {
-            const timeReservedAtEnd = this.blockDuration + // Last sub-slot for validator re-execution
-            this.checkpointFinalizationTime; // Checkpoint finalization
-            const timeAvailableForBlocks = this.aztecSlotDuration - this.initializationOffset - timeReservedAtEnd;
-            this.maxNumberOfBlocks = Math.floor(timeAvailableForBlocks / this.blockDuration);
-        }
-        // Minimum work to do within a slot for building a block with the minimum time for execution and publishing its checkpoint
-        const minWorkToDo = this.initializationOffset + this.minExecutionTime * 2 + // Execution and reexecution
-        this.checkpointFinalizationTime;
-        const initializeDeadline = this.aztecSlotDuration - minWorkToDo;
-        this.initializeDeadline = initializeDeadline;
-        this.log?.info(`Sequencer timetable initialized with ${this.maxNumberOfBlocks} blocks per slot (${this.enforce ? 'enforced' : 'not enforced'})`, {
-            ethereumSlotDuration: this.ethereumSlotDuration,
-            aztecSlotDuration: this.aztecSlotDuration,
-            l1PublishingTime: this.l1PublishingTime,
-            minExecutionTime: this.minExecutionTime,
-            blockPrepareTime: this.checkpointInitializationTime,
-            p2pPropagationTime: this.p2pPropagationTime,
-            blockAssembleTime: this.checkpointAssembleTime,
-            initializeDeadline: this.initializeDeadline,
-            enforce: this.enforce,
-            minWorkToDo,
-            blockDuration: this.blockDuration,
-            maxNumberOfBlocks: this.maxNumberOfBlocks
-        });
-        if (initializeDeadline <= 0) {
-            throw new Error(`Block proposal initialize deadline cannot be negative (got ${initializeDeadline} from total time needed ${minWorkToDo} and a slot duration of ${this.aztecSlotDuration}).`);
-        }
-    }
-    getMaxAllowedTime(state) {
-        switch(state){
-            case SequencerState.STOPPED:
-            case SequencerState.STOPPING:
-            case SequencerState.IDLE:
-            case SequencerState.SYNCHRONIZING:
-                return; // We don't really care about times for this states
-            case SequencerState.PROPOSER_CHECK:
-            case SequencerState.INITIALIZING_CHECKPOINT:
-                return this.initializeDeadline;
-            case SequencerState.WAITING_FOR_TXS:
-            case SequencerState.CREATING_BLOCK:
-            case SequencerState.WAITING_UNTIL_NEXT_BLOCK:
-                return this.initializeDeadline + this.checkpointInitializationTime;
-            case SequencerState.ASSEMBLING_CHECKPOINT:
-            case SequencerState.COLLECTING_ATTESTATIONS:
-                return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.p2pPropagationTime;
-            case SequencerState.PUBLISHING_CHECKPOINT:
-                return this.aztecSlotDuration - this.l1PublishingTime;
-            default:
-                {
-                    const _exhaustiveCheck = state;
-                    throw new Error(`Unexpected state: ${state}`);
-                }
-        }
-    }
-    assertTimeLeft(newState, secondsIntoSlot) {
-        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
-        });
-    }
-    /**
-   * Determines if we can start building the next block and returns its deadline.
-   *
-   * The timetable divides the slot into fixed sub-slots. This method finds the next
-   * available sub-slot that has enough time remaining to build a block.
-   *
-   * @param secondsIntoSlot - Current time (seconds into the slot)
-   * @returns Object with canStart flag, deadline, and whether this is the last block
-   */ canStartNextBlock(secondsIntoSlot) {
-        // When timetable enforcement is disabled, always allow starting,
-        // and build a single block with no deadline. This is here just to
-        // satisfy a subset of e2e tests and the sandbox that assume that the
-        // sequencer is permanently mining every tx sent.
-        if (!this.enforce) {
-            return {
-                canStart: true,
-                deadline: undefined,
-                isLastBlock: true
-            };
-        }
-        // If no block duration is set, then we're in single-block mode, which
-        // is handled for backwards compatibility towards another subset of e2e tests.
-        if (this.blockDuration === undefined) {
-            // In single block mode, execution and re-execution happen sequentially, so we need to
-            // split the available time between them. After building, we need time for attestations and L1.
-            const maxAllowed = this.aztecSlotDuration - this.checkpointFinalizationTime;
-            const available = (maxAllowed - secondsIntoSlot) / 2; // Split remaining time: half for execution, half for re-execution
-            const canStart = available >= this.minExecutionTime;
-            const deadline = secondsIntoSlot + available;
-            this.log?.verbose(`${canStart ? 'Can' : 'Cannot'} start single-block checkpoint at ${secondsIntoSlot}s into slot`, {
-                secondsIntoSlot,
-                maxAllowed,
-                available,
-                deadline
-            });
-            return {
-                canStart,
-                deadline,
-                isLastBlock: true
-            };
-        }
-        // Otherwise, we're in multi-block-per-slot mode, the default when running in production
-        // Find the next available sub-slot that has enough time remaining
-        for(let subSlot = 1; subSlot <= this.maxNumberOfBlocks; subSlot++){
-            // Calculate end for this sub-slot
-            const deadline = this.initializationOffset + subSlot * this.blockDuration;
-            // Check if we have enough time to build a block with this deadline
-            const timeUntilDeadline = deadline - secondsIntoSlot;
-            if (timeUntilDeadline >= this.minExecutionTime) {
-                // Found an available sub-slot! Is this the last one?
-                const isLastBlock = subSlot === this.maxNumberOfBlocks;
-                this.log?.verbose(`Can start ${isLastBlock ? 'last block' : 'block'} in sub-slot ${subSlot} with deadline ${deadline}s`, {
-                    secondsIntoSlot,
-                    deadline,
-                    timeUntilDeadline,
-                    subSlot,
-                    maxBlocks: this.maxNumberOfBlocks
-                });
-                return {
-                    canStart: true,
-                    deadline,
-                    isLastBlock
-                };
-            }
-        }
-        // No sub-slots available with enough time
-        this.log?.verbose(`No time left to start any more blocks`, {
-            secondsIntoSlot,
-            maxBlocks: this.maxNumberOfBlocks,
-            initializationOffset: this.initializationOffset
-        });
-        return {
-            canStart: false,
-            deadline: undefined,
-            isLastBlock: false
-        };
-    }
-}