@aztec/sequencer-client 0.0.1-commit.10bd49492 → 0.0.1-commit.11bf3dd6e

package/src/sequencer/timetable.ts

@@ -2,8 +2,10 @@ import type { Logger } from '@aztec/foundation/log';
 import {
   CHECKPOINT_ASSEMBLE_TIME,
   CHECKPOINT_INITIALIZATION_TIME,
+  type CheckpointTiming,
   DEFAULT_P2P_PROPAGATION_TIME,
   MIN_EXECUTION_TIME,
+  createCheckpointTimingModel,
 } from '@aztec/stdlib/timetable';
 
 import { SequencerTooSlowError } from './errors.js';
@@ -11,6 +13,8 @@ import type { SequencerMetrics } from './metrics.js';
 import { SequencerState } from './utils.js';
 
 export class SequencerTimetable {
+  private readonly checkpointTiming: CheckpointTiming;
+
   /**
    * 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
@@ -70,6 +74,15 @@ export class SequencerTimetable {
   /** Maximum number of blocks that can be built in this slot configuration */
   public readonly maxNumberOfBlocks: number;
 
+  /** Whether pipelining is enabled (checkpoint finalization deferred to next slot). */
+  public readonly pipelining: boolean;
+
+  /**
+   * How far into the target slot attestation collection can extend when pipelining.
+   * Covers validator re-execution (one block duration) plus one-way attestation return.
+   */
+  public readonly pipeliningAttestationGracePeriod: number;
+
   constructor(
     opts: {
       ethereumSlotDuration: number;
@@ -78,6 +91,7 @@ export class SequencerTimetable {
       p2pPropagationTime?: number;
       blockDurationMs?: number;
       enforce: boolean;
+      pipelining?: boolean;
     },
     private readonly metrics?: SequencerMetrics,
     private readonly log?: Logger,
@@ -85,52 +99,31 @@ export class SequencerTimetable {
     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;
+    this.pipelining = opts.pipelining ?? false;
+
+    this.checkpointTiming = createCheckpointTimingModel({
+      aztecSlotDuration: this.aztecSlotDuration,
+      ethereumSlotDuration: this.ethereumSlotDuration,
+      blockDuration: this.blockDuration,
+      l1PublishingTime: this.l1PublishingTime,
+      p2pPropagationTime: opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME,
+      pipelining: this.pipelining,
+    });
 
-    // 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;
-    }
+    this.p2pPropagationTime = this.checkpointTiming.p2pPropagationTime;
+    this.checkpointAssembleTime = this.checkpointTiming.checkpointAssembleTime;
+    this.checkpointInitializationTime = this.checkpointTiming.checkpointInitializationTime;
+    this.minExecutionTime = this.checkpointTiming.minExecutionTime;
 
     // 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.initializationOffset = this.checkpointTiming.checkpointInitializationTime;
+    this.checkpointFinalizationTime = this.checkpointTiming.checkpointFinalizationTime;
+    this.pipeliningAttestationGracePeriod = this.checkpointTiming.pipeliningAttestationGracePeriod;
+    this.maxNumberOfBlocks = this.checkpointTiming.calculateMaxBlocksPerSlot();
+    this.initializeDeadline = this.checkpointTiming.initializeDeadline;
 
     this.log?.info(
       `Sequencer timetable initialized with ${this.maxNumberOfBlocks} blocks per slot (${this.enforce ? 'enforced' : 'not enforced'})`,
@@ -144,19 +137,37 @@ export class SequencerTimetable {
         blockAssembleTime: this.checkpointAssembleTime,
         initializeDeadline: this.initializeDeadline,
         enforce: this.enforce,
-        minWorkToDo,
+        pipelining: this.pipelining,
+        pipeliningAttestationGracePeriod: this.pipeliningAttestationGracePeriod,
+        minWorkToDo: this.checkpointTiming.minimumBuildSlotWork,
         blockDuration: this.blockDuration,
         maxNumberOfBlocks: this.maxNumberOfBlocks,
       },
     );
 
-    if (initializeDeadline <= 0) {
+    if (this.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}).`,
+        `Block proposal initialize deadline cannot be negative (got ${this.initializeDeadline} from total time needed ${this.checkpointTiming.minimumBuildSlotWork} and a slot duration of ${this.aztecSlotDuration}).`,
       );
     }
   }
 
+  public getCheckpointAssemblyDeadline(): number {
+    return this.checkpointTiming.checkpointAssemblyDeadline;
+  }
+
+  public getCheckpointAttestationDeadline(): number {
+    return this.checkpointTiming.checkpointAttestationDeadline;
+  }
+
+  public getCheckpointAttestationStartDeadline(): number {
+    return this.checkpointTiming.checkpointAttestationStartDeadline;
+  }
+
+  public getCheckpointPublishingDeadline(): number {
+    return this.checkpointTiming.checkpointPublishingDeadline;
+  }
+
   public getMaxAllowedTime(
     state: Extract<SequencerState, SequencerState.STOPPED | SequencerState.IDLE | SequencerState.SYNCHRONIZING>,
   ): undefined;
@@ -179,10 +190,11 @@ export class SequencerTimetable {
       case SequencerState.WAITING_UNTIL_NEXT_BLOCK:
         return this.initializeDeadline + this.checkpointInitializationTime;
       case SequencerState.ASSEMBLING_CHECKPOINT:
+        return this.getCheckpointAssemblyDeadline();
       case SequencerState.COLLECTING_ATTESTATIONS:
-        return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.p2pPropagationTime;
+        return this.getCheckpointAttestationStartDeadline();
       case SequencerState.PUBLISHING_CHECKPOINT:
-        return this.aztecSlotDuration - this.l1PublishingTime;
+        return this.getCheckpointPublishingDeadline();
       default: {
         const _exhaustiveCheck: never = state;
         throw new Error(`Unexpected state: ${state}`);

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;
+    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 });