@aztec/sequencer-client 0.0.1-commit.f504929 → 0.0.1-commit.f5a9928

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'
+  '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

@@ -1,14 +1,14 @@
-import { type BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { type BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { unfreeze } from '@aztec/foundation/types';
 import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
-import { Gas } from '@aztec/stdlib/gas';
 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;
+    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,
+    opts: BlockBuilderOptions,
   ): Promise<BuildBlockInCheckpointResult> {
     this.buildBlockCalls.push({ blockNumber, timestamp, opts });
 
@@ -86,8 +86,10 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
     let usedTxs: Tx[];
 
     if (this.blockProvider) {
-      // Dynamic mode: get block from provider
-      block = this.blockProvider();
+      // Dynamic mode: get block from provider, cloning to avoid shared references across multiple buildBlock calls
+      block = L2Block.fromBuffer(this.blockProvider().toBuffer());
+      block.header.globalVariables.blockNumber = blockNumber;
+      await block.header.recomputeHash();
       usedTxs = [];
       this.builtBlocks.push(block);
     } else {
@@ -113,81 +115,79 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
 
     return {
       block,
-      publicGas: Gas.empty(),
       publicProcessorDuration: 0,
       numTxs: block?.body?.txEffects?.length ?? usedTxs.length,
       usedTxs,
       failedTxs: [],
-      usedTxBlobFields: block?.body?.txEffects?.reduce((sum, tx) => sum + tx.getNumBlobFields(), 0) ?? 0,
     };
   }
 
   completeCheckpoint(): Promise<Checkpoint> {
     this.completeCheckpointCalled = true;
     const allBlocks = this.blockProvider ? this.builtBlocks : this.blocks;
-    const lastBlock = allBlocks[allBlocks.length - 1];
-    // Create a CheckpointHeader from the last block's header for testing
-    const checkpointHeader = this.createCheckpointHeader(lastBlock);
-    return Promise.resolve(
-      new Checkpoint(
-        makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
-        checkpointHeader,
-        allBlocks,
-        this.checkpointNumber,
-      ),
-    );
+    return this.buildCheckpoint(allBlocks);
   }
 
   getCheckpoint(): Promise<Checkpoint> {
     this.getCheckpointCalled = true;
     const builtBlocks = this.blockProvider ? this.builtBlocks : this.blocks.slice(0, this.blockIndex);
-    const lastBlock = builtBlocks[builtBlocks.length - 1];
-    if (!lastBlock) {
+    if (builtBlocks.length === 0) {
       throw new Error('No blocks built yet');
     }
-    // Create a CheckpointHeader from the last block's header for testing
-    const checkpointHeader = this.createCheckpointHeader(lastBlock);
-    return Promise.resolve(
-      new Checkpoint(
-        makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
-        checkpointHeader,
-        builtBlocks,
-        this.checkpointNumber,
-      ),
-    );
+    return this.buildCheckpoint(builtBlocks);
   }
 
-  /**
-   * Creates a CheckpointHeader from a block's header for testing.
-   * This is a simplified version that creates a minimal CheckpointHeader.
-   */
-  private createCheckpointHeader(block: L2Block): CheckpointHeader {
-    const header = block.header;
-    const gv = header.globalVariables;
-    return CheckpointHeader.empty({
-      lastArchiveRoot: header.lastArchive.root,
-      blockHeadersHash: Fr.random(), // Use random for testing
+  /** Builds a structurally valid Checkpoint from a list of blocks, fixing up indexes and archive chaining. */
+  private async buildCheckpoint(blocks: L2Block[]): Promise<Checkpoint> {
+    // Fix up indexWithinCheckpoint and archive chaining so the checkpoint passes structural validation.
+    for (let i = 0; i < blocks.length; i++) {
+      blocks[i].indexWithinCheckpoint = IndexWithinCheckpoint(i);
+      if (i > 0) {
+        unfreeze(blocks[i].header).lastArchive = blocks[i - 1].archive;
+        await blocks[i].header.recomputeHash();
+      }
+    }
+
+    const firstBlock = blocks[0];
+    const lastBlock = blocks[blocks.length - 1];
+    const gv = firstBlock.header.globalVariables;
+
+    const checkpointHeader = CheckpointHeader.empty({
+      lastArchiveRoot: firstBlock.header.lastArchive.root,
+      blockHeadersHash: Fr.random(),
       slotNumber: gv.slotNumber,
       timestamp: gv.timestamp,
       coinbase: gv.coinbase,
       feeRecipient: gv.feeRecipient,
       gasFees: gv.gasFees,
-      totalManaUsed: header.totalManaUsed,
+      totalManaUsed: lastBlock.header.totalManaUsed,
     });
+
+    return new Checkpoint(
+      makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
+      checkpointHeader,
+      blocks,
+      this.checkpointNumber,
+    );
   }
 
-  /** Reset for reuse in another test */
-  reset(): void {
-    this.blocks = [];
+  /** Resets per-checkpoint state (built blocks, consumed txs) while preserving config (blockProvider, seeded blocks). */
+  resetCheckpointState(): void {
     this.builtBlocks = [];
-    this.usedTxsPerBlock = [];
     this.blockIndex = 0;
-    this.buildBlockCalls = [];
     this.consumedTxHashes.clear();
     this.completeCheckpointCalled = false;
     this.getCheckpointCalled = false;
+  }
+
+  /** Reset for reuse in another test */
+  reset(): void {
+    this.blocks = [];
+    this.usedTxsPerBlock = [];
+    this.buildBlockCalls = [];
     this.errorOnBuild = undefined;
     this.blockProvider = undefined;
+    this.resetCheckpointState();
   }
 }
 
@@ -249,6 +249,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
       slotDuration: 24,
       l1ChainId: 1,
       rollupVersion: 1,
+      rollupManaLimit: 200_000_000,
     };
   }
 
@@ -275,6 +276,8 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
     if (!this.checkpointBuilder) {
       // Auto-create a builder if none was set
       this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    } else {
+      this.checkpointBuilder.resetCheckpointState();
     }
 
     return Promise.resolve(this.checkpointBuilder);

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
  */
@@ -55,6 +90,7 @@ export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Pr
  */
 export function mockPendingTxs(p2p: MockProxy<P2P>, txs: Tx[]): void {
   p2p.getPendingTxCount.mockResolvedValue(txs.length);
+  p2p.hasEligiblePendingTxs.mockImplementation(minCount => Promise.resolve(txs.length >= minCount));
   p2p.iteratePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
   p2p.iterateEligiblePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
 }
@@ -94,6 +130,7 @@ function createCheckpointHeaderFromBlock(block: L2Block): CheckpointHeader {
     gv.feeRecipient,
     gv.gasFees,
     block.header.totalManaUsed,
+    block.header.totalFees,
   );
 }
 
@@ -109,6 +146,7 @@ export function createBlockProposal(block: L2Block, signature: Signature): Block
     block.archive.root,
     txHashes,
     signature,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
   );
 }
 
@@ -123,12 +161,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 +188,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,87 +0,0 @@
-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?: import("@aztec/aztec.js/log").Logger);
-    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":"AASA,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;IArEtB;;;;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,uCAAsC,EA2E3D;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,223 +0,0 @@
-import { createLogger } from '@aztec/aztec.js/log';
-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 = createLogger('sequencer:timetable')){
-        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
-        };
-    }
-}