@aztec/sequencer-client 0.0.1-commit.f5d02921e → 0.0.1-commit.f7ea82942

package/src/sequencer/checkpoint_proposal_job_metrics.ts

@@ -0,0 +1,128 @@
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  type Meter,
+  Metrics,
+  type TelemetryClient,
+} from '@aztec/telemetry-client';
+
+type CheckpointProposalJobInstruments = {
+  checkpointAttestationDelay: Histogram;
+  checkpointBuildDuration: Histogram;
+  checkpointStartToFirstBlockDuration: Histogram;
+  checkpointLastBlockToBroadcastDuration: Histogram;
+  pipelinedCheckpointBuildStartOffsetFromSlotBoundary: Histogram;
+  checkpointBlockCount: Gauge;
+  checkpointTxCount: Gauge;
+  checkpointTotalMana: Gauge;
+};
+
+/**
+ * Per-job recording surface used by {@link CheckpointProposalJob}.
+ *
+ * Ownership split:
+ * - {@link CheckpointProposalJobMetrics} owns the OpenTelemetry meter and instruments and should live for the
+ *   lifetime of the sequencer process.
+ * - A recorder owns only mutable timing state for one checkpoint proposal job so overlapping jobs cannot
+ *   overwrite each other's timing markers.
+ */
+export interface CheckpointProposalJobMetricsRecorder {
+  recordCheckpointAttestationDelay(durationMs: number): void;
+  recordCheckpointBuild(durationMs: number, blockCount: number, txCount: number, totalMana: number): void;
+  recordPipelinedCheckpointBuildStartOffsetFromSlotBoundary(offsetMs: number): void;
+  startCheckpointTiming(nowMs: number): void;
+  noteCheckpointBlockBuilt(nowMs: number, opts: { isFirstBlock: boolean; isLastBlock: boolean }): void;
+  noteCheckpointBroadcast(nowMs: number): void;
+}
+
+/**
+ * Concrete per-job recorder.
+ *
+ * This class should be short-lived: create one recorder per checkpoint proposal job and discard it when the job
+ * completes. It intentionally does not create instruments; it only holds the job-local timestamps needed to derive
+ * timing metrics safely.
+ */
+class CheckpointProposalJobMetricsRecorderImpl implements CheckpointProposalJobMetricsRecorder {
+  private checkpointStartedAt?: number;
+  private checkpointLastBlockBuiltAt?: number;
+
+  constructor(private readonly instruments: CheckpointProposalJobInstruments) {}
+
+  public recordCheckpointAttestationDelay(durationMs: number) {
+    this.instruments.checkpointAttestationDelay.record(Math.ceil(durationMs));
+  }
+
+  public recordCheckpointBuild(durationMs: number, blockCount: number, txCount: number, totalMana: number) {
+    this.instruments.checkpointBuildDuration.record(Math.ceil(durationMs));
+    this.instruments.checkpointBlockCount.record(blockCount);
+    this.instruments.checkpointTxCount.record(txCount);
+    this.instruments.checkpointTotalMana.record(totalMana);
+  }
+
+  public recordPipelinedCheckpointBuildStartOffsetFromSlotBoundary(offsetMs: number) {
+    this.instruments.pipelinedCheckpointBuildStartOffsetFromSlotBoundary.record(Math.ceil(Math.abs(offsetMs)), {
+      [Attributes.SLOT_BOUNDARY_SIDE]: offsetMs < 0 ? 'before' : 'after',
+    });
+  }
+
+  public startCheckpointTiming(nowMs: number) {
+    this.checkpointStartedAt = nowMs;
+    this.checkpointLastBlockBuiltAt = undefined;
+  }
+
+  public noteCheckpointBlockBuilt(nowMs: number, opts: { isFirstBlock: boolean; isLastBlock: boolean }) {
+    if (opts.isFirstBlock && this.checkpointStartedAt !== undefined) {
+      this.instruments.checkpointStartToFirstBlockDuration.record(Math.ceil(nowMs - this.checkpointStartedAt));
+    }
+
+    if (opts.isLastBlock) {
+      this.checkpointLastBlockBuiltAt = nowMs;
+    }
+  }
+
+  public noteCheckpointBroadcast(nowMs: number) {
+    if (this.checkpointLastBlockBuiltAt !== undefined) {
+      this.instruments.checkpointLastBlockToBroadcastDuration.record(
+        Math.ceil(nowMs - this.checkpointLastBlockBuiltAt),
+      );
+    }
+
+    this.checkpointLastBlockBuiltAt = undefined;
+  }
+}
+
+/**
+ * Long-lived owner of checkpoint proposal job telemetry instruments.
+ *
+ * The sequencer should construct this once and reuse it across jobs. Each call to {@link createRecorder} returns a
+ * lightweight recorder with isolated mutable state for a single checkpoint proposal job.
+ */
+export class CheckpointProposalJobMetrics {
+  private readonly meter: Meter;
+  private readonly instruments: CheckpointProposalJobInstruments;
+
+  constructor(client: TelemetryClient, name = 'CheckpointProposalJob') {
+    this.meter = client.getMeter(name);
+    this.instruments = {
+      checkpointAttestationDelay: this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY),
+      checkpointBuildDuration: this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_BUILD_DURATION),
+      checkpointStartToFirstBlockDuration: this.meter.createHistogram(
+        Metrics.SEQUENCER_CHECKPOINT_START_TO_FIRST_BLOCK_DURATION,
+      ),
+      checkpointLastBlockToBroadcastDuration: this.meter.createHistogram(
+        Metrics.SEQUENCER_CHECKPOINT_LAST_BLOCK_TO_BROADCAST_DURATION,
+      ),
+      pipelinedCheckpointBuildStartOffsetFromSlotBoundary: this.meter.createHistogram(
+        Metrics.SEQUENCER_PIPELINED_CHECKPOINT_BUILD_START_OFFSET_FROM_SLOT_BOUNDARY,
+      ),
+      checkpointBlockCount: this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_BLOCK_COUNT),
+      checkpointTxCount: this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TX_COUNT),
+      checkpointTotalMana: this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TOTAL_MANA),
+    };
+  }
+
+  public createRecorder(): CheckpointProposalJobMetricsRecorder {
+    return new CheckpointProposalJobMetricsRecorderImpl(this.instruments);
+  }
+}

package/src/sequencer/events.ts

@@ -24,4 +24,9 @@ export type SequencerEvents = {
   }) => void;
   ['checkpoint-published']: (args: { checkpoint: CheckpointNumber; slot: SlotNumber }) => void;
   ['checkpoint-error']: (args: { error: Error }) => void;
+  ['pipelined-checkpoint-discarded']: (args: {
+    slot: SlotNumber;
+    checkpointNumber: CheckpointNumber;
+    reason: string;
+  }) => void;
 };

package/src/sequencer/metrics.ts

@@ -44,13 +44,9 @@ export class SequencerMetrics {
   private checkpointProposalFailed: UpDownCounter;
   private checkpointSuccess: UpDownCounter;
   private slashingAttempts: UpDownCounter;
-  private checkpointAttestationDelay: Histogram;
-  private checkpointBuildDuration: Histogram;
-  private checkpointBlockCount: Gauge;
-  private checkpointTxCount: Gauge;
-  private checkpointTotalMana: Gauge;
   private pipelineDepth: Gauge;
   private pipelineDiscards: UpDownCounter;
+  private pipelineParentCheckpointMismatches: UpDownCounter;
 
   // Fisherman fee analysis metrics
   private fishermanWouldBeIncluded: UpDownCounter;
@@ -68,6 +64,10 @@ export class SequencerMetrics {
   private fishermanMinedBlobTxPriorityFee: Histogram;
   private fishermanMinedBlobTxTotalCost: Histogram;
 
+  private blockInterBlockTime: Histogram;
+  private lastBlockBuiltTimestamp?: number;
+  private lastBlockBuiltSlot?: SlotNumber;
+
   private lastSeenSlot?: SlotNumber;
 
   constructor(
@@ -86,9 +86,9 @@ export class SequencerMetrics {
 
     this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND);
 
-    this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION);
+    this.blockInterBlockTime = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_INTER_BLOCK_TIME);
 
-    this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
+    this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION);
 
     this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_SLOT_REWARDS);
 
@@ -138,15 +138,23 @@ export class SequencerMetrics {
       Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_FAILED_COUNT,
     );
 
-    this.checkpointBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_BUILD_DURATION);
-    this.checkpointBlockCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_BLOCK_COUNT);
-    this.checkpointTxCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TX_COUNT);
-    this.checkpointTotalMana = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TOTAL_MANA);
-
     this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
 
     this.pipelineDepth = this.meter.createGauge(Metrics.SEQUENCER_PIPELINE_DEPTH);
     this.pipelineDiscards = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_PIPELINE_DISCARDS_COUNT);
+    this.pipelineParentCheckpointMismatches = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_PIPELINE_PARENT_CHECKPOINT_MISMATCH_COUNT,
+      {
+        [Attributes.ERROR_TYPE]: [
+          'archiver-sync-timeout',
+          'parent-not-on-l1',
+          'parent-hash-mismatch',
+          'parent-invalid-attestations',
+          'unexpected-parent-appeared',
+        ],
+      },
+    );
     this.pipelineDepth.record(0);
 
     // Fisherman fee analysis metrics
@@ -211,21 +219,25 @@ export class SequencerMetrics {
     this.timeToCollectAttestations.record(0);
   }
 
-  public recordCheckpointAttestationDelay(duration: number) {
-    this.checkpointAttestationDelay.record(duration);
-  }
-
   public recordCollectedAttestations(count: number, durationMs: number) {
     this.collectedAttestions.record(count);
     this.timeToCollectAttestations.record(Math.ceil(durationMs));
   }
 
-  recordBuiltBlock(buildDurationMs: number, totalMana: number) {
+  recordBuiltBlock(buildDurationMs: number, totalMana: number, slot: SlotNumber) {
     this.blockCounter.add(1, {
       [Attributes.STATUS]: 'built',
     });
     this.blockBuildDuration.record(Math.ceil(buildDurationMs));
     this.blockBuildManaPerSecond.record(Math.ceil((totalMana * 1000) / buildDurationMs));
+
+    // Only record inter-block time between blocks built within the same slot.
+    const now = Date.now();
+    if (this.lastBlockBuiltTimestamp !== undefined && this.lastBlockBuiltSlot === slot) {
+      this.blockInterBlockTime.record(now - this.lastBlockBuiltTimestamp);
+    }
+    this.lastBlockBuiltTimestamp = now;
+    this.lastBlockBuiltSlot = slot;
   }
 
   recordFailedBlock() {
@@ -248,6 +260,12 @@ export class SequencerMetrics {
     this.pipelineDiscards.add(count);
   }
 
+  recordPipelineParentCheckpointMismatch(reason: string) {
+    this.pipelineParentCheckpointMismatches.add(1, {
+      [Attributes.ERROR_TYPE]: reason,
+    });
+  }
+
   incOpenSlot(slot: SlotNumber, proposer: string) {
     // sequencer went through the loop a second time. Noop
     if (slot === this.lastSeenSlot) {
@@ -306,14 +324,6 @@ export class SequencerMetrics {
     });
   }
 
-  /** Records aggregate metrics for a completed checkpoint build. */
-  recordCheckpointBuild(durationMs: number, blockCount: number, txCount: number, totalMana: number) {
-    this.checkpointBuildDuration.record(Math.ceil(durationMs));
-    this.checkpointBlockCount.record(blockCount);
-    this.checkpointTxCount.record(txCount);
-    this.checkpointTotalMana.record(totalMana);
-  }
-
   recordSlashingAttempt(actionCount: number) {
     this.slashingAttempts.add(actionCount);
   }

package/src/sequencer/sequencer.ts

@@ -1,7 +1,7 @@
 import { getKzg } from '@aztec/blob-lib';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { NoCommitteeError, type RollupContract } from '@aztec/ethereum/contracts';
+import { NoCommitteeError, type RollupContract, SimulationOverridesBuilder } from '@aztec/ethereum/contracts';
 import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { merge, omit, pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -34,6 +34,7 @@ import type { GlobalVariableBuilder } from '../global_variable_builder/global_bu
 import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
 import type { InvalidateCheckpointRequest, SequencerPublisher } from '../publisher/sequencer-publisher.js';
 import { CheckpointProposalJob } from './checkpoint_proposal_job.js';
+import { CheckpointProposalJobMetrics } from './checkpoint_proposal_job_metrics.js';
 import { CheckpointVoter } from './checkpoint_voter.js';
 import { SequencerInterruptedError, SequencerTooSlowError } from './errors.js';
 import type { SequencerEvents } from './events.js';
@@ -56,6 +57,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   private runningPromise?: RunningPromise;
   private state = SequencerState.STOPPED;
   private metrics: SequencerMetrics;
+  private checkpointProposalJobMetrics: CheckpointProposalJobMetrics;
 
   /** The last slot for which we attempted to perform our voting duties with degraded block production */
   private lastSlotForFallbackVote: SlotNumber | undefined;
@@ -73,7 +75,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   private lastEpochForStrategyComparison: EpochNumber | undefined;
 
   /** The last checkpoint proposal job, tracked so we can await its pending L1 submission during shutdown. */
-  private lastCheckpointProposalJob: CheckpointProposalJob | undefined;
+  protected lastCheckpointProposalJob: CheckpointProposalJob | undefined;
 
   /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */
   protected timetable!: SequencerTimetable;
@@ -107,6 +109,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     }
 
     this.metrics = new SequencerMetrics(telemetry, this.rollupContract, 'Sequencer');
+    this.checkpointProposalJobMetrics = new CheckpointProposalJobMetrics(telemetry);
     this.updateConfig(config);
   }
 
@@ -115,14 +118,16 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     const filteredConfig = pickFromSchema(config, SequencerConfigSchema);
     this.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowListExtend'));
     this.config = merge(this.config, filteredConfig);
+    const p2pPropagationTime = this.config.attestationPropagationTime;
     this.timetable = new SequencerTimetable(
       {
         ethereumSlotDuration: this.l1Constants.ethereumSlotDuration,
         aztecSlotDuration: this.aztecSlotDuration,
         l1PublishingTime: this.l1PublishingTime,
-        p2pPropagationTime: this.config.attestationPropagationTime,
+        p2pPropagationTime,
         blockDurationMs: this.config.blockDurationMs,
         enforce: this.config.enforceTimeTable,
+        pipelining: this.epochCache.isProposerPipeliningEnabled(),
       },
       this.metrics,
       this.log,
@@ -146,6 +151,11 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     this.log.info('Started sequencer');
   }
 
+  /** Triggers an immediate run of the sequencer, bypassing the polling interval. */
+  public trigger() {
+    return this.runningPromise?.trigger();
+  }
+
   /** Stops the sequencer from building blocks and moves to STOPPED state. */
   public async stop(): Promise<void> {
     this.log.info(`Stopping sequencer`);
@@ -299,16 +309,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     // Next checkpoint follows from the last synced one
     const checkpointNumber = CheckpointNumber(syncedTo.checkpointNumber + 1);
 
-    // Guard: don't exceed 1-deep pipeline. Without a proposed checkpoint, we can only build
-    // confirmed + 1. With a proposed checkpoint, we can build confirmed + 2.
-    const confirmedCkpt = syncedTo.checkpointedCheckpointNumber;
-    if (checkpointNumber > confirmedCkpt + 2) {
-      this.log.warn(
-        `Skipping slot ${targetSlot}: checkpoint ${checkpointNumber} exceeds max pipeline depth (confirmed=${confirmedCkpt})`,
-      );
-      return undefined;
-    }
-
     const logCtx = {
       nowSeconds,
       syncedToL2Slot: syncedTo.syncedL2Slot,
@@ -329,6 +329,16 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       return undefined;
     }
 
+    // Guard: don't exceed 1-deep pipeline. Without a proposed checkpoint, we can only build
+    // confirmed + 1. With a proposed checkpoint, we can build confirmed + 2.
+    const confirmedCkpt = syncedTo.checkpointedCheckpointNumber;
+    if (checkpointNumber > confirmedCkpt + 2) {
+      this.log.verbose(
+        `Skipping slot ${targetSlot}: checkpoint ${checkpointNumber} exceeds max pipeline depth (confirmed=${confirmedCkpt})`,
+      );
+      return undefined;
+    }
+
     // Check that the target slot is not taken by a block already (should never happen, since only us can propose for this slot)
     if (syncedTo.blockData && syncedTo.blockData.header.getSlot() >= targetSlot) {
       this.log.warn(
@@ -360,17 +370,13 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     // The L1 contract reads archives[proposedCheckpointNumber] and compares it with the provided archive.
     // When invalidating or pipelining, the local archive may differ from L1's, so we adjust accordingly.
     let archiveForCheck = syncedTo.archive;
-    const l1Overrides: {
-      forcePendingCheckpointNumber?: CheckpointNumber;
-      forceArchive?: { checkpointNumber: CheckpointNumber; archive: Fr };
-    } = {};
+    const l1SimulationOverridesBuilder = new SimulationOverridesBuilder();
 
     if (this.epochCache.isProposerPipeliningEnabled() && syncedTo.hasProposedCheckpoint) {
       // Parent checkpoint hasn't landed on L1 yet. Override both the proposed checkpoint number
       // and the archive at that checkpoint so L1 simulation sees the correct chain tip.
       const parentCheckpointNumber = CheckpointNumber(checkpointNumber - 1);
-      l1Overrides.forcePendingCheckpointNumber = parentCheckpointNumber;
-      l1Overrides.forceArchive = { checkpointNumber: parentCheckpointNumber, archive: syncedTo.archive };
+      l1SimulationOverridesBuilder.forPendingCheckpoint(parentCheckpointNumber).withPendingArchive(syncedTo.archive);
       this.metrics.recordPipelineDepth(1);
 
       this.log.verbose(
@@ -382,13 +388,18 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       // After invalidation, L1 will roll back to checkpoint N-1. The archive at N-1 already
       // exists on L1, so we just pass the matching archive (the lastArchive of the invalid checkpoint).
       archiveForCheck = invalidateCheckpoint.lastArchive;
-      l1Overrides.forcePendingCheckpointNumber = invalidateCheckpoint.forcePendingCheckpointNumber;
+      l1SimulationOverridesBuilder.forPendingCheckpoint(invalidateCheckpoint.forcePendingCheckpointNumber);
       this.metrics.recordPipelineDepth(0);
     } else {
       this.metrics.recordPipelineDepth(0);
     }
 
-    const canProposeCheck = await publisher.canProposeAt(archiveForCheck, proposer ?? EthAddress.ZERO, l1Overrides);
+    const simulationOverridesPlan = l1SimulationOverridesBuilder.build();
+    const canProposeCheck = await publisher.canProposeAt(
+      archiveForCheck,
+      proposer ?? EthAddress.ZERO,
+      simulationOverridesPlan,
+    );
 
     if (canProposeCheck === undefined) {
       this.log.warn(
@@ -484,6 +495,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       this.epochCache,
       this.dateProvider,
       this.metrics,
+      this.checkpointProposalJobMetrics.createRecorder(),
       this,
       this.setState.bind(this),
       this.tracer,
@@ -567,12 +579,12 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         .getL2Tips()
         .then(t => ({ proposed: t.proposed, checkpointed: t.checkpointed, proposedCheckpoint: t.proposedCheckpoint })),
       this.p2pClient.getStatus().then(p2p => p2p.syncedToL2Block),
-      this.l1ToL2MessageSource.getL2Tips().then(t => t.proposed),
+      this.l1ToL2MessageSource.getL2Tips().then(t => ({ proposed: t.proposed, checkpointed: t.checkpointed })),
       this.l2BlockSource.getPendingChainValidationStatus(),
       this.l2BlockSource.getProposedCheckpointOnly(),
     ] as const);
 
-    const [worldState, l2Tips, p2p, l1ToL2MessageSource, pendingChainValidationStatus, proposedCheckpointData] =
+    const [worldState, l2Tips, p2p, l1ToL2MessageSourceTips, pendingChainValidationStatus, proposedCheckpointData] =
       syncedBlocks;
 
     // Handle zero as a special case, since the block hash won't match across services if we're changing the prefilled data for the genesis block,
@@ -580,19 +592,25 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     // TODO(palla/mbps): Fix the above. All components should be able to handle dynamic genesis block hashes.
     const result =
       (l2Tips.proposed.number === 0 &&
+        l2Tips.checkpointed.block.number === 0 &&
+        l2Tips.checkpointed.checkpoint.number === 0 &&
         worldState.number === 0 &&
         p2p.number === 0 &&
-        l1ToL2MessageSource.number === 0) ||
+        l1ToL2MessageSourceTips.proposed.number === 0 &&
+        l1ToL2MessageSourceTips.checkpointed.block.number === 0 &&
+        l1ToL2MessageSourceTips.checkpointed.checkpoint.number === 0) ||
       (worldState.hash === l2Tips.proposed.hash &&
         p2p.hash === l2Tips.proposed.hash &&
-        l1ToL2MessageSource.hash === l2Tips.proposed.hash);
+        l1ToL2MessageSourceTips.proposed.hash === l2Tips.proposed.hash &&
+        l1ToL2MessageSourceTips.checkpointed.block.hash === l2Tips.checkpointed.block.hash &&
+        l1ToL2MessageSourceTips.checkpointed.checkpoint.hash === l2Tips.checkpointed.checkpoint.hash);
 
     if (!result) {
       this.log.debug(`Sequencer sync check failed`, {
         worldState,
         l2BlockSource: l2Tips.proposed,
         p2p,
-        l1ToL2MessageSource,
+        l1ToL2MessageSourceTips,
       });
       return undefined;
     }

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