@aztec/sequencer-client 3.0.0-nightly.20251224 → 3.0.0-nightly.20251225

package/src/sequencer/sequencer.ts

@@ -1,4 +1,3 @@
-import { L2Block } from '@aztec/aztec.js/block';
 import { getKzg } from '@aztec/blob-lib';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
@@ -13,7 +12,7 @@ import type { DateProvider } from '@aztec/foundation/timer';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
-import type { L2BlockSource, ValidateBlockResult } from '@aztec/stdlib/block';
+import type { L2BlockNew, L2BlockSource, ValidateBlockResult } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import {
@@ -225,6 +224,8 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       this.logStrategyComparison(epoch, checkpointProposalJob.getPublisher());
       this.lastEpochForStrategyComparison = epoch;
     }
+
+    return checkpoint;
   }
 
   /**
@@ -496,8 +497,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       return { blockNumber: BlockNumber(INITIAL_L2_BLOCK_NUM - 1), archive, l1Timestamp, pendingChainValidationStatus };
     }
 
-    // TODO(palla/mbps): This should be a new L2Block
-    const block = await this.l2BlockSource.getBlock(blockNumber);
+    const block = await this.l2BlockSource.getL2BlockNew(blockNumber);
     if (!block) {
       // this shouldn't really happen because a moment ago we checked that all components were in sync
       this.log.error(`Failed to get L2 block ${blockNumber} from the archiver with all components in sync`);
@@ -788,7 +788,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
 }
 
 type SequencerSyncCheckResult = {
-  block?: L2Block;
+  block?: L2BlockNew;
   blockNumber: BlockNumber;
   archive: Fr;
   l1Timestamp: bigint;

package/src/sequencer/timetable.ts

@@ -5,9 +5,9 @@ import { SequencerTooSlowError } from './errors.js';
 import type { SequencerMetrics } from './metrics.js';
 import { SequencerState } from './utils.js';
 
-export const MIN_EXECUTION_TIME = 1;
+export const MIN_EXECUTION_TIME = 2;
 export const CHECKPOINT_INITIALIZATION_TIME = 1;
-export const CHECKPOINT_FINALIZATION_TIME = 1;
+export const CHECKPOINT_ASSEMBLE_TIME = 1;
 
 export class SequencerTimetable {
   /**
@@ -17,6 +17,21 @@ export class SequencerTimetable {
    */
   public 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.
+   */
+  public 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
+   */
+  public 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,
@@ -36,8 +51,8 @@ export class SequencerTimetable {
   /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */
   public readonly p2pPropagationTime: number;
 
-  /** How much time we spend validating and processing a checkpoint after building it */
-  public readonly checkpointFinalizationTime: number = CHECKPOINT_FINALIZATION_TIME;
+  /** How much time we spend assembling a checkpoint after building the last block */
+  public readonly checkpointAssembleTime: number = CHECKPOINT_ASSEMBLE_TIME;
 
   /** Ethereum slot duration in seconds */
   public readonly ethereumSlotDuration: number;
@@ -51,6 +66,9 @@ export class SequencerTimetable {
   /** Duration per block when building multiple blocks per slot (undefined = single block per slot) */
   public readonly blockDuration: number | undefined;
 
+  /** Maximum number of blocks that can be built in this slot configuration */
+  public readonly maxNumberOfBlocks: number;
+
   constructor(
     opts: {
       ethereumSlotDuration: number;
@@ -68,39 +86,68 @@ export class SequencerTimetable {
     this.l1PublishingTime = opts.l1PublishingTime;
     this.p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
     this.blockDuration = opts.blockDurationMs ? opts.blockDurationMs / 1000 : undefined;
-    this.minExecutionTime = MIN_EXECUTION_TIME;
     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.checkpointFinalizationTime = 0.5;
+      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.checkpointInitializationTime +
+      this.initializationOffset +
       this.minExecutionTime * 2 + // Execution and reexecution
-      this.checkpointFinalizationTime +
-      this.p2pPropagationTime * 2 + // Send proposal and receive attestations
-      this.l1PublishingTime; // Submit to L1
+      this.checkpointFinalizationTime;
 
     const initializeDeadline = this.aztecSlotDuration - minWorkToDo;
     this.initializeDeadline = initializeDeadline;
 
-    this.log.verbose(`Sequencer timetable initialized (${this.enforce ? 'enforced' : 'not enforced'})`, {
-      ethereumSlotDuration: this.ethereumSlotDuration,
-      aztecSlotDuration: this.aztecSlotDuration,
-      l1PublishingTime: this.l1PublishingTime,
-      minExecutionTime: this.minExecutionTime,
-      blockPrepareTime: this.checkpointInitializationTime,
-      p2pPropagationTime: this.p2pPropagationTime,
-      blockValidationTime: this.checkpointFinalizationTime,
-      initializeDeadline: this.initializeDeadline,
-      enforce: this.enforce,
-      allWorkToDo: minWorkToDo,
-    });
+    this.log.verbose(
+      `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(
@@ -109,36 +156,6 @@ export class SequencerTimetable {
     }
   }
 
-  /** Deadline for a block proposal execution. Ensures we have enough time left for reexecution and publishing. */
-  public getProposerExecTimeEnd(secondsIntoSlot: number): number {
-    // We are N seconds into the slot. We need to account for `afterBlockBuildingTimeNeededWithoutReexec` seconds,
-    // send then split the remaining time between the re-execution and the block building.
-    const afterBlockBuildingTimeNeededWithoutReexec =
-      this.checkpointFinalizationTime + this.p2pPropagationTime * 2 + this.l1PublishingTime;
-    const maxAllowed = this.aztecSlotDuration - afterBlockBuildingTimeNeededWithoutReexec;
-    const available = maxAllowed - secondsIntoSlot;
-    const executionTimeEnd = secondsIntoSlot + available / 2;
-    this.log.debug(`Block proposal execution time deadline is ${executionTimeEnd}`, {
-      secondsIntoSlot,
-      maxAllowed,
-      available,
-      executionTimeEnd,
-    });
-    return executionTimeEnd;
-  }
-
-  /** Deadline for block proposal reexecution. Ensures the proposer has enough time for publishing. */
-  public getValidatorReexecTimeEnd(secondsIntoSlot?: number): number {
-    // We need to leave for `afterBlockReexecTimeNeeded` seconds available.
-    const afterBlockReexecTimeNeeded = this.p2pPropagationTime + this.l1PublishingTime;
-    const validationTimeEnd = this.aztecSlotDuration - afterBlockReexecTimeNeeded;
-    this.log.debug(`Validator re-execution time deadline is ${validationTimeEnd}`, {
-      secondsIntoSlot,
-      validationTimeEnd,
-    });
-    return validationTimeEnd;
-  }
-
   public getMaxAllowedTime(
     state: Extract<SequencerState, SequencerState.STOPPED | SequencerState.IDLE | SequencerState.SYNCHRONIZING>,
   ): undefined;
@@ -160,7 +177,7 @@ export class SequencerTimetable {
       case SequencerState.CREATING_BLOCK:
       case SequencerState.WAITING_UNTIL_NEXT_BLOCK:
         return this.initializeDeadline + this.checkpointInitializationTime;
-      case SequencerState.FINALIZING_CHECKPOINT:
+      case SequencerState.ASSEMBLING_CHECKPOINT:
       case SequencerState.COLLECTING_ATTESTATIONS:
         return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.p2pPropagationTime;
       case SequencerState.PUBLISHING_CHECKPOINT:
@@ -192,32 +209,74 @@ export class SequencerTimetable {
   }
 
   /**
-   * Get timing information for building blocks within a slot.
-   * @param secondsIntoSlot - Current seconds into the slot
-   * @returns Object containing:
-   *   - canStart: boolean - Whether there's time to start a block now
-   *   - deadline: number - Deadline (seconds into slot) for building the block
-   *   - isLastBlock: boolean - Whether the next block would be the last one in the checkpoint
+   * 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
    */
-  public canStartNextBlock(secondsIntoSlot: number): {
-    canStart: boolean;
-    deadline: number | undefined;
-    isLastBlock: boolean;
-  } {
-    const minExecutionTime = this.minExecutionTime;
-    const deadline = this.enforce ? this.getProposerExecTimeEnd(secondsIntoSlot) : undefined;
-
-    // Always allow to start if we don't enforce the timetable
-    const canStart = !this.enforce || deadline === undefined || deadline - secondsIntoSlot >= minExecutionTime;
-
-    // Single block per slot
+  public canStartNextBlock(
+    secondsIntoSlot: number,
+  ):
+    | { canStart: true; deadline: undefined; isLastBlock: true }
+    | { canStart: false; deadline: undefined; isLastBlock: false }
+    | { canStart: boolean; deadline: number; isLastBlock: boolean } {
+    // 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) {
-      this.log.debug(`${canStart ? 'Can' : 'Cannot'} start single-block checkpoint at ${secondsIntoSlot}s into slot`);
-      return { deadline, canStart, isLastBlock: true };
+      // 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 };
+      }
     }
 
-    // Multiple blocks per slot
-    // TODO(palla/mbps) Implement me
-    return { deadline, canStart, isLastBlock: true };
+    // 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 };
   }
 }

package/src/sequencer/utils.ts

@@ -17,8 +17,8 @@ export enum SequencerState {
   CREATING_BLOCK = 'CREATING_BLOCK',
   /** Waiting until the next block can be created. */
   WAITING_UNTIL_NEXT_BLOCK = 'WAITING_UNTIL_NEXT_BLOCK',
-  /** Finalizing and broadcasting the checkpoint. */
-  FINALIZING_CHECKPOINT = 'FINALIZING_CHECKPOINT',
+  /** Assembling and broadcasting the checkpoint. */
+  ASSEMBLING_CHECKPOINT = 'ASSEMBLING_CHECKPOINT',
   /** Collecting attestations from its peers. */
   COLLECTING_ATTESTATIONS = 'COLLECTING_ATTESTATIONS',
   /** Sending the tx to L1 with the L2 checkpoint data and awaiting it to be mined.. */
@@ -33,7 +33,7 @@ export type SequencerStateWithSlot =
   | SequencerState.COLLECTING_ATTESTATIONS
   | SequencerState.PUBLISHING_CHECKPOINT
   | SequencerState.PROPOSER_CHECK
-  | SequencerState.FINALIZING_CHECKPOINT;
+  | SequencerState.ASSEMBLING_CHECKPOINT;
 
 export type SequencerStateCallback = () => SequencerState;
 

package/src/test/mock_checkpoint_builder.ts

@@ -0,0 +1,247 @@
+import { type BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Timer } from '@aztec/foundation/timer';
+import type { FunctionsOf } from '@aztec/foundation/types';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { Gas } from '@aztec/stdlib/gas';
+import type { FullNodeBlockBuilderConfig, PublicProcessorLimits } from '@aztec/stdlib/interfaces/server';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
+import type { CheckpointGlobalVariables, Tx } from '@aztec/stdlib/tx';
+
+import type {
+  BuildBlockInCheckpointResult,
+  CheckpointBuilder,
+  FullNodeCheckpointsBuilder,
+} from '../sequencer/checkpoint_builder.js';
+
+/**
+ * A fake CheckpointBuilder for testing that implements the same interface as the real one.
+ * Can be seeded with blocks to return sequentially on each `buildBlock` call.
+ */
+export class MockCheckpointBuilder implements FunctionsOf<CheckpointBuilder> {
+  private blocks: L2BlockNew[] = [];
+  private builtBlocks: L2BlockNew[] = [];
+  private usedTxsPerBlock: Tx[][] = [];
+  private blockIndex = 0;
+
+  /** Optional function to dynamically provide the block (alternative to seedBlocks) */
+  private blockProvider: (() => L2BlockNew) | undefined = undefined;
+
+  /** Track calls for assertions */
+  public buildBlockCalls: Array<{
+    blockNumber: BlockNumber;
+    timestamp: bigint;
+    opts: PublicProcessorLimits;
+  }> = [];
+  public completeCheckpointCalled = false;
+  public getCheckpointCalled = false;
+
+  /** Set to an error to make buildBlock throw on next call */
+  public errorOnBuild: Error | undefined = undefined;
+
+  constructor(
+    private readonly constants: CheckpointGlobalVariables,
+    private readonly checkpointNumber: CheckpointNumber,
+  ) {}
+
+  /** Seed the builder with blocks to return on successive buildBlock calls */
+  seedBlocks(blocks: L2BlockNew[], usedTxsPerBlock?: Tx[][]): this {
+    this.blocks = blocks;
+    this.usedTxsPerBlock = usedTxsPerBlock ?? blocks.map(() => []);
+    this.blockIndex = 0;
+    this.blockProvider = undefined;
+    return this;
+  }
+
+  /**
+   * Set a function that provides blocks dynamically.
+   * Useful for tests where the block is determined at call time (e.g., sequencer tests).
+   */
+  setBlockProvider(provider: () => L2BlockNew): this {
+    this.blockProvider = provider;
+    this.blocks = [];
+    return this;
+  }
+
+  getConstantData(): CheckpointGlobalVariables {
+    return this.constants;
+  }
+
+  buildBlock(
+    _pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: PublicProcessorLimits,
+  ): Promise<BuildBlockInCheckpointResult> {
+    this.buildBlockCalls.push({ blockNumber, timestamp, opts });
+
+    if (this.errorOnBuild) {
+      return Promise.reject(this.errorOnBuild);
+    }
+
+    let block: L2BlockNew;
+    let usedTxs: Tx[];
+
+    if (this.blockProvider) {
+      // Dynamic mode: get block from provider
+      block = this.blockProvider();
+      usedTxs = [];
+      this.builtBlocks.push(block);
+    } else {
+      // Seeded mode: get block from pre-seeded list
+      block = this.blocks[this.blockIndex];
+      usedTxs = this.usedTxsPerBlock[this.blockIndex] ?? [];
+      this.blockIndex++;
+      this.builtBlocks.push(block);
+    }
+
+    return Promise.resolve({
+      block,
+      publicGas: Gas.empty(),
+      publicProcessorDuration: 0,
+      numTxs: block?.body?.txEffects?.length ?? usedTxs.length,
+      blockBuildingTimer: new Timer(),
+      usedTxs,
+      failedTxs: [],
+    });
+  }
+
+  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,
+      ),
+    );
+  }
+
+  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) {
+      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,
+      ),
+    );
+  }
+
+  /**
+   * Creates a CheckpointHeader from a block's header for testing.
+   * This is a simplified version that creates a minimal CheckpointHeader.
+   */
+  private createCheckpointHeader(block: L2BlockNew): CheckpointHeader {
+    const header = block.header;
+    const gv = header.globalVariables;
+    return CheckpointHeader.empty({
+      lastArchiveRoot: header.lastArchive.root,
+      blockHeadersHash: Fr.random(), // Use random for testing
+      slotNumber: gv.slotNumber,
+      timestamp: gv.timestamp,
+      coinbase: gv.coinbase,
+      feeRecipient: gv.feeRecipient,
+      gasFees: gv.gasFees,
+      totalManaUsed: header.totalManaUsed,
+    });
+  }
+
+  /** Reset for reuse in another test */
+  reset(): void {
+    this.blocks = [];
+    this.builtBlocks = [];
+    this.usedTxsPerBlock = [];
+    this.blockIndex = 0;
+    this.buildBlockCalls = [];
+    this.completeCheckpointCalled = false;
+    this.getCheckpointCalled = false;
+    this.errorOnBuild = undefined;
+    this.blockProvider = undefined;
+  }
+}
+
+/**
+ * A fake CheckpointsBuilder (factory) for testing that implements the same interface
+ * as FullNodeCheckpointsBuilder. Returns MockCheckpointBuilder instances.
+ * Does NOT use jest mocks - this is a proper test double.
+ */
+export class MockCheckpointsBuilder implements FunctionsOf<FullNodeCheckpointsBuilder> {
+  private checkpointBuilder: MockCheckpointBuilder | undefined;
+
+  /** Track calls for assertions */
+  public startCheckpointCalls: Array<{
+    checkpointNumber: CheckpointNumber;
+    constants: CheckpointGlobalVariables;
+    l1ToL2Messages: Fr[];
+  }> = [];
+  public updateConfigCalls: Array<Partial<FullNodeBlockBuilderConfig>> = [];
+
+  /**
+   * Set the MockCheckpointBuilder to return from startCheckpoint.
+   * Must be called before startCheckpoint is invoked.
+   */
+  setCheckpointBuilder(builder: MockCheckpointBuilder): this {
+    this.checkpointBuilder = builder;
+    return this;
+  }
+
+  /**
+   * Creates a new MockCheckpointBuilder with the given constants.
+   * Convenience method that creates and sets the builder in one call.
+   */
+  createCheckpointBuilder(
+    constants: CheckpointGlobalVariables,
+    checkpointNumber: CheckpointNumber,
+  ): MockCheckpointBuilder {
+    this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    return this.checkpointBuilder;
+  }
+
+  /** Get the current checkpoint builder (for assertions) */
+  getCheckpointBuilder(): MockCheckpointBuilder | undefined {
+    return this.checkpointBuilder;
+  }
+
+  updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void {
+    this.updateConfigCalls.push(config);
+  }
+
+  startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    _fork: unknown,
+  ): Promise<CheckpointBuilder> {
+    this.startCheckpointCalls.push({ checkpointNumber, constants, l1ToL2Messages });
+
+    if (!this.checkpointBuilder) {
+      // Auto-create a builder if none was set
+      this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    }
+
+    return Promise.resolve(this.checkpointBuilder as unknown as CheckpointBuilder);
+  }
+
+  /** Reset for reuse in another test */
+  reset(): void {
+    this.checkpointBuilder = undefined;
+    this.startCheckpointCalls = [];
+    this.updateConfigCalls = [];
+  }
+}