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

package/dest/sequencer/timetable.js

@@ -2,9 +2,9 @@ import { createLogger } from '@aztec/aztec.js/log';
 import { DEFAULT_ATTESTATION_PROPAGATION_TIME as DEFAULT_P2P_PROPAGATION_TIME } from '../config.js';
 import { SequencerTooSlowError } from './errors.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 {
     metrics;
     log;
@@ -14,6 +14,17 @@ export class SequencerTimetable {
    * 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.
@@ -24,77 +35,73 @@ export class SequencerTimetable {
    */ 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 validating and processing a checkpoint after building it */ checkpointFinalizationTime;
+    /** 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.checkpointFinalizationTime = CHECKPOINT_FINALIZATION_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.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.minExecutionTime * 2 + // Execution and reexecution
-        this.checkpointFinalizationTime + this.p2pPropagationTime * 2 + // Send proposal and receive attestations
-        this.l1PublishingTime; // Submit to L1
+        const minWorkToDo = this.initializationOffset + this.minExecutionTime * 2 + // Execution and reexecution
+        this.checkpointFinalizationTime;
         const initializeDeadline = this.aztecSlotDuration - minWorkToDo;
         this.initializeDeadline = initializeDeadline;
-        this.log.verbose(`Sequencer timetable initialized (${this.enforce ? 'enforced' : 'not enforced'})`, {
+        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,
-            blockValidationTime: this.checkpointFinalizationTime,
+            blockAssembleTime: this.checkpointAssembleTime,
             initializeDeadline: this.initializeDeadline,
             enforce: this.enforce,
-            allWorkToDo: minWorkToDo
+            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}).`);
         }
     }
-    /** Deadline for a block proposal execution. Ensures we have enough time left for reexecution and publishing. */ getProposerExecTimeEnd(secondsIntoSlot) {
-        // 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. */ getValidatorReexecTimeEnd(secondsIntoSlot) {
-        // 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;
-    }
     getMaxAllowedTime(state) {
         switch(state){
             case SequencerState.STOPPED:
@@ -109,7 +116,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:
@@ -140,32 +147,80 @@ 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
    */ canStartNextBlock(secondsIntoSlot) {
-        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
+        // 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`);
+            // 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 {
-                deadline,
                 canStart,
+                deadline,
                 isLastBlock: true
             };
         }
-        // Multiple blocks per slot
-        // TODO(palla/mbps) Implement me
+        // 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 {
-            deadline,
-            canStart,
-            isLastBlock: true
+            canStart: false,
+            deadline: undefined,
+            isLastBlock: false
         };
     }
 }

package/dest/sequencer/utils.d.ts

@@ -17,14 +17,14 @@ export declare 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.. */
     PUBLISHING_CHECKPOINT = "PUBLISHING_CHECKPOINT"
 }
-export type SequencerStateWithSlot = SequencerState.INITIALIZING_CHECKPOINT | SequencerState.WAITING_FOR_TXS | SequencerState.CREATING_BLOCK | SequencerState.WAITING_UNTIL_NEXT_BLOCK | SequencerState.COLLECTING_ATTESTATIONS | SequencerState.PUBLISHING_CHECKPOINT | SequencerState.PROPOSER_CHECK | SequencerState.FINALIZING_CHECKPOINT;
+export type SequencerStateWithSlot = SequencerState.INITIALIZING_CHECKPOINT | SequencerState.WAITING_FOR_TXS | SequencerState.CREATING_BLOCK | SequencerState.WAITING_UNTIL_NEXT_BLOCK | SequencerState.COLLECTING_ATTESTATIONS | SequencerState.PUBLISHING_CHECKPOINT | SequencerState.PROPOSER_CHECK | SequencerState.ASSEMBLING_CHECKPOINT;
 export type SequencerStateCallback = () => SequencerState;
 export declare function sequencerStateToNumber(state: SequencerState): number;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXF1ZW5jZXIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQVksY0FBYztJQUN4QixxRUFBcUU7SUFDckUsT0FBTyxZQUFZO0lBQ25CLGdFQUFnRTtJQUNoRSxRQUFRLGFBQWE7SUFDckIscURBQXFEO0lBQ3JELElBQUksU0FBUztJQUNiLHVDQUF1QztJQUN2QyxhQUFhLGtCQUFrQjtJQUMvQiw0REFBNEQ7SUFDNUQsY0FBYyxtQkFBbUI7SUFDakMsNENBQTRDO0lBQzVDLHVCQUF1Qiw0QkFBNEI7SUFDbkQsc0RBQXNEO0lBQ3RELGVBQWUsb0JBQW9CO0lBQ25DLDBFQUEwRTtJQUMxRSxjQUFjLG1CQUFtQjtJQUNqQyxtREFBbUQ7SUFDbkQsd0JBQXdCLDZCQUE2QjtJQUNyRCxrREFBa0Q7SUFDbEQscUJBQXFCLDBCQUEwQjtJQUMvQyw4Q0FBOEM7SUFDOUMsdUJBQXVCLDRCQUE0QjtJQUNuRCxxRkFBcUY7SUFDckYscUJBQXFCLDBCQUEwQjtDQUNoRDtBQUVELE1BQU0sTUFBTSxzQkFBc0IsR0FDOUIsY0FBYyxDQUFDLHVCQUF1QixHQUN0QyxjQUFjLENBQUMsZUFBZSxHQUM5QixjQUFjLENBQUMsY0FBYyxHQUM3QixjQUFjLENBQUMsd0JBQXdCLEdBQ3ZDLGNBQWMsQ0FBQyx1QkFBdUIsR0FDdEMsY0FBYyxDQUFDLHFCQUFxQixHQUNwQyxjQUFjLENBQUMsY0FBYyxHQUM3QixjQUFjLENBQUMscUJBQXFCLENBQUM7QUFFekMsTUFBTSxNQUFNLHNCQUFzQixHQUFHLE1BQU0sY0FBYyxDQUFDO0FBRTFELHdCQUFnQixzQkFBc0IsQ0FBQyxLQUFLLEVBQUUsY0FBYyxHQUFHLE1BQU0sQ0FFcEUifQ==

package/dest/sequencer/utils.js

@@ -8,7 +8,7 @@ export var SequencerState = /*#__PURE__*/ function(SequencerState) {
     /** Waiting for transactions to arrive in the pool. */ SequencerState["WAITING_FOR_TXS"] = "WAITING_FOR_TXS";
     /** Creating a new L2 block. Includes processing public function calls. */ SequencerState["CREATING_BLOCK"] = "CREATING_BLOCK";
     /** Waiting until the next block can be created. */ SequencerState["WAITING_UNTIL_NEXT_BLOCK"] = "WAITING_UNTIL_NEXT_BLOCK";
-    /** Finalizing and broadcasting the checkpoint. */ SequencerState["FINALIZING_CHECKPOINT"] = "FINALIZING_CHECKPOINT";
+    /** Assembling and broadcasting the checkpoint. */ SequencerState["ASSEMBLING_CHECKPOINT"] = "ASSEMBLING_CHECKPOINT";
     /** Collecting attestations from its peers. */ SequencerState["COLLECTING_ATTESTATIONS"] = "COLLECTING_ATTESTATIONS";
     /** Sending the tx to L1 with the L2 checkpoint data and awaiting it to be mined.. */ SequencerState["PUBLISHING_CHECKPOINT"] = "PUBLISHING_CHECKPOINT";
     return SequencerState;

package/dest/test/mock_checkpoint_builder.d.ts

@@ -0,0 +1,83 @@
+import { type BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { FunctionsOf } from '@aztec/foundation/types';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { FullNodeBlockBuilderConfig, PublicProcessorLimits } from '@aztec/stdlib/interfaces/server';
+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 declare class MockCheckpointBuilder implements FunctionsOf<CheckpointBuilder> {
+    private readonly constants;
+    private readonly checkpointNumber;
+    private blocks;
+    private builtBlocks;
+    private usedTxsPerBlock;
+    private blockIndex;
+    /** Optional function to dynamically provide the block (alternative to seedBlocks) */
+    private blockProvider;
+    /** Track calls for assertions */
+    buildBlockCalls: Array<{
+        blockNumber: BlockNumber;
+        timestamp: bigint;
+        opts: PublicProcessorLimits;
+    }>;
+    completeCheckpointCalled: boolean;
+    getCheckpointCalled: boolean;
+    /** Set to an error to make buildBlock throw on next call */
+    errorOnBuild: Error | undefined;
+    constructor(constants: CheckpointGlobalVariables, checkpointNumber: CheckpointNumber);
+    /** Seed the builder with blocks to return on successive buildBlock calls */
+    seedBlocks(blocks: L2BlockNew[], usedTxsPerBlock?: Tx[][]): 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;
+    getConstantData(): CheckpointGlobalVariables;
+    buildBlock(_pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, blockNumber: BlockNumber, timestamp: bigint, opts: PublicProcessorLimits): Promise<BuildBlockInCheckpointResult>;
+    completeCheckpoint(): Promise<Checkpoint>;
+    getCheckpoint(): Promise<Checkpoint>;
+    /**
+     * Creates a CheckpointHeader from a block's header for testing.
+     * This is a simplified version that creates a minimal CheckpointHeader.
+     */
+    private createCheckpointHeader;
+    /** Reset for reuse in another test */
+    reset(): void;
+}
+/**
+ * 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 declare class MockCheckpointsBuilder implements FunctionsOf<FullNodeCheckpointsBuilder> {
+    private checkpointBuilder;
+    /** Track calls for assertions */
+    startCheckpointCalls: Array<{
+        checkpointNumber: CheckpointNumber;
+        constants: CheckpointGlobalVariables;
+        l1ToL2Messages: Fr[];
+    }>;
+    updateConfigCalls: Array<Partial<FullNodeBlockBuilderConfig>>;
+    /**
+     * Set the MockCheckpointBuilder to return from startCheckpoint.
+     * Must be called before startCheckpoint is invoked.
+     */
+    setCheckpointBuilder(builder: MockCheckpointBuilder): 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;
+    /** Get the current checkpoint builder (for assertions) */
+    getCheckpointBuilder(): MockCheckpointBuilder | undefined;
+    updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void;
+    startCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, l1ToL2Messages: Fr[], _fork: unknown): Promise<CheckpointBuilder>;
+    /** Reset for reuse in another test */
+    reset(): void;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/test/mock_checkpoint_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock_checkpoint_builder.d.ts","sourceRoot":"","sources":["../../src/test/mock_checkpoint_builder.ts"],"names":[],"mappings":"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"}

package/dest/test/mock_checkpoint_builder.js

@@ -0,0 +1,179 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Timer } from '@aztec/foundation/timer';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { Gas } from '@aztec/stdlib/gas';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
+/**
+ * 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 {
+    constants;
+    checkpointNumber;
+    blocks;
+    builtBlocks;
+    usedTxsPerBlock;
+    blockIndex;
+    /** Optional function to dynamically provide the block (alternative to seedBlocks) */ blockProvider;
+    /** Track calls for assertions */ buildBlockCalls;
+    completeCheckpointCalled;
+    getCheckpointCalled;
+    /** Set to an error to make buildBlock throw on next call */ errorOnBuild;
+    constructor(constants, checkpointNumber){
+        this.constants = constants;
+        this.checkpointNumber = checkpointNumber;
+        this.blocks = [];
+        this.builtBlocks = [];
+        this.usedTxsPerBlock = [];
+        this.blockIndex = 0;
+        this.blockProvider = undefined;
+        this.buildBlockCalls = [];
+        this.completeCheckpointCalled = false;
+        this.getCheckpointCalled = false;
+        this.errorOnBuild = undefined;
+    }
+    /** Seed the builder with blocks to return on successive buildBlock calls */ seedBlocks(blocks, usedTxsPerBlock) {
+        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) {
+        this.blockProvider = provider;
+        this.blocks = [];
+        return this;
+    }
+    getConstantData() {
+        return this.constants;
+    }
+    buildBlock(_pendingTxs, blockNumber, timestamp, opts) {
+        this.buildBlockCalls.push({
+            blockNumber,
+            timestamp,
+            opts
+        });
+        if (this.errorOnBuild) {
+            return Promise.reject(this.errorOnBuild);
+        }
+        let block;
+        let usedTxs;
+        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() {
+        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() {
+        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.
+   */ createCheckpointHeader(block) {
+        const header = block.header;
+        const gv = header.globalVariables;
+        return CheckpointHeader.empty({
+            lastArchiveRoot: header.lastArchive.root,
+            blockHeadersHash: Fr.random(),
+            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() {
+        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 {
+    checkpointBuilder;
+    /** Track calls for assertions */ startCheckpointCalls = [];
+    updateConfigCalls = [];
+    /**
+   * Set the MockCheckpointBuilder to return from startCheckpoint.
+   * Must be called before startCheckpoint is invoked.
+   */ setCheckpointBuilder(builder) {
+        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, checkpointNumber) {
+        this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+        return this.checkpointBuilder;
+    }
+    /** Get the current checkpoint builder (for assertions) */ getCheckpointBuilder() {
+        return this.checkpointBuilder;
+    }
+    updateConfig(config) {
+        this.updateConfigCalls.push(config);
+    }
+    startCheckpoint(checkpointNumber, constants, l1ToL2Messages, _fork) {
+        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);
+    }
+    /** Reset for reuse in another test */ reset() {
+        this.checkpointBuilder = undefined;
+        this.startCheckpointCalls = [];
+        this.updateConfigCalls = [];
+    }
+}

package/dest/test/utils.d.ts

@@ -0,0 +1,49 @@
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import type { P2P } from '@aztec/p2p';
+import { CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
+import { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
+import { GlobalVariables, type Tx } from '@aztec/stdlib/tx';
+import type { MockProxy } from 'jest-mock-extended';
+export { MockCheckpointBuilder, MockCheckpointsBuilder } from './mock_checkpoint_builder.js';
+/**
+ * Creates a mock transaction with a specific seed for deterministic testing
+ */
+export declare function makeTx(seed?: number, chainId?: Fr): Promise<Tx>;
+/**
+ * Creates an L2BlockNew from transactions and global variables
+ */
+export declare function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Promise<L2BlockNew>;
+/**
+ * Mocks the P2P client to return specific pending transactions
+ */
+export declare function mockPendingTxs(p2p: MockProxy<P2P>, txs: Tx[]): void;
+/**
+ * Creates an async iterator for transactions
+ */
+export declare function mockTxIterator(txs: Promise<Tx[]>): AsyncIterableIterator<Tx>;
+/**
+ * Creates mock committee attestations from a signer
+ */
+export declare function createMockSignatures(signer: Secp256k1Signer): CommitteeAttestation[];
+/**
+ * Creates a block proposal from a block and signature
+ */
+export declare function createBlockProposal(block: L2BlockNew, signature: Signature): BlockProposal;
+/**
+ * Creates a block attestation from a block and signature.
+ * Note: We manually set the sender since we use random signatures in tests.
+ * In production, the sender is recovered from the signature.
+ */
+export declare function createBlockAttestation(block: L2BlockNew, signature: Signature, sender: EthAddress): BlockAttestation;
+/**
+ * Creates transactions and a block, and mocks P2P to return them.
+ * Helper for tests that need to set up a block with transactions.
+ */
+export declare function setupTxsAndBlock(p2p: MockProxy<P2P>, globalVariables: GlobalVariables, txCount: number, chainId: Fr): Promise<{
+    txs: Tx[];
+    block: L2BlockNew;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUM1RSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDaEUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzVELE9BQU8sS0FBSyxFQUFFLEdBQUcsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV0QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsVUFBVSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDdkUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGFBQWEsRUFBb0IsTUFBTSxtQkFBbUIsQ0FBQztBQUd0RixPQUFPLEVBR0wsZUFBZSxFQUNmLEtBQUssRUFBRSxFQUVSLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHcEQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLHNCQUFzQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFN0Y7O0dBRUc7QUFDSCx3QkFBc0IsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQU1yRTtBQUVEOztHQUVHO0FBQ0gsd0JBQXNCLFNBQVMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxFQUFFLEVBQUUsZUFBZSxFQUFFLGVBQWUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBVWhHO0FBRUQ7O0dBRUc7QUFDSCx3QkFBZ0IsY0FBYyxDQUFDLEdBQUcsRUFBRSxTQUFTLENBQUMsR0FBRyxDQUFDLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxHQUFHLElBQUksQ0FHbkU7QUFFRDs7R0FFRztBQUNILHdCQUF1QixjQUFjLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLHFCQUFxQixDQUFDLEVBQUUsQ0FBQyxDQUluRjtBQUVEOztHQUVHO0FBQ0gsd0JBQWdCLG9CQUFvQixDQUFDLE1BQU0sRUFBRSxlQUFlLEdBQUcsb0JBQW9CLEVBQUUsQ0FHcEY7QUFzQkQ7O0dBRUc7QUFDSCx3QkFBZ0IsbUJBQW1CLENBQUMsS0FBSyxFQUFFLFVBQVUsRUFBRSxTQUFTLEVBQUUsU0FBUyxHQUFHLGFBQWEsQ0FLMUY7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQWdCLHNCQUFzQixDQUFDLEtBQUssRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsVUFBVSxHQUFHLGdCQUFnQixDQVFwSDtBQUVEOzs7R0FHRztBQUNILHdCQUFzQixnQkFBZ0IsQ0FDcEMsR0FBRyxFQUFFLFNBQVMsQ0FBQyxHQUFHLENBQUMsRUFDbkIsZUFBZSxFQUFFLGVBQWUsRUFDaEMsT0FBTyxFQUFFLE1BQU0sRUFDZixPQUFPLEVBQUUsRUFBRSxHQUNWLE9BQU8sQ0FBQztJQUFFLEdBQUcsRUFBRSxFQUFFLEVBQUUsQ0FBQztJQUFDLEtBQUssRUFBRSxVQUFVLENBQUE7Q0FBRSxDQUFDLENBSzNDIn0=

package/dest/test/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAoB,MAAM,mBAAmB,CAAC;AAGtF,OAAO,EAGL,eAAe,EACf,KAAK,EAAE,EAER,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAE7F;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAMrE;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAUhG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,IAAI,CAGnE;AAED;;GAEG;AACH,wBAAuB,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,GAAG,qBAAqB,CAAC,EAAE,CAAC,CAInF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,oBAAoB,EAAE,CAGpF;AAsBD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,aAAa,CAK1F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,gBAAgB,CAQpH;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,EACnB,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,EAAE,GACV,OAAO,CAAC;IAAE,GAAG,EAAE,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC,CAK3C"}