@aztec/sequencer-client 0.0.1-commit.e3c1de76 → 0.0.1-commit.e588bc7e5

package/src/sequencer/timetable.ts

@@ -1,14 +1,15 @@
-import { createLogger } from '@aztec/aztec.js/log';
+import type { Logger } from '@aztec/foundation/log';
+import {
+  CHECKPOINT_ASSEMBLE_TIME,
+  CHECKPOINT_INITIALIZATION_TIME,
+  DEFAULT_P2P_PROPAGATION_TIME,
+  MIN_EXECUTION_TIME,
+} from '@aztec/stdlib/timetable';
 
-import { DEFAULT_ATTESTATION_PROPAGATION_TIME as DEFAULT_P2P_PROPAGATION_TIME } from '../config.js';
 import { SequencerTooSlowError } from './errors.js';
 import type { SequencerMetrics } from './metrics.js';
 import { SequencerState } from './utils.js';
 
-export const MIN_EXECUTION_TIME = 2;
-export const CHECKPOINT_INITIALIZATION_TIME = 1;
-export const CHECKPOINT_ASSEMBLE_TIME = 1;
-
 export class SequencerTimetable {
   /**
    * How late into the slot can we be to start working. Computed as the total time needed for assembling and publishing a block,
@@ -79,7 +80,7 @@ export class SequencerTimetable {
       enforce: boolean;
     },
     private readonly metrics?: SequencerMetrics,
-    private readonly log = createLogger('sequencer:timetable'),
+    private readonly log?: Logger,
   ) {
     this.ethereumSlotDuration = opts.ethereumSlotDuration;
     this.aztecSlotDuration = opts.aztecSlotDuration;
@@ -131,7 +132,7 @@ export class SequencerTimetable {
     const initializeDeadline = this.aztecSlotDuration - minWorkToDo;
     this.initializeDeadline = initializeDeadline;
 
-    this.log.verbose(
+    this.log?.info(
       `Sequencer timetable initialized with ${this.maxNumberOfBlocks} blocks per slot (${this.enforce ? 'enforced' : 'not enforced'})`,
       {
         ethereumSlotDuration: this.ethereumSlotDuration,
@@ -205,7 +206,7 @@ export class SequencerTimetable {
     }
 
     this.metrics?.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), newState);
-    this.log.trace(`Enough time to transition to ${newState}`, { maxAllowedTime, secondsIntoSlot });
+    this.log?.trace(`Enough time to transition to ${newState}`, { maxAllowedTime, secondsIntoSlot });
   }
 
   /**
@@ -241,7 +242,7 @@ export class SequencerTimetable {
       const canStart = available >= this.minExecutionTime;
       const deadline = secondsIntoSlot + available;
 
-      this.log.verbose(
+      this.log?.verbose(
         `${canStart ? 'Can' : 'Cannot'} start single-block checkpoint at ${secondsIntoSlot}s into slot`,
         { secondsIntoSlot, maxAllowed, available, deadline },
       );
@@ -261,7 +262,7 @@ export class SequencerTimetable {
         // Found an available sub-slot! Is this the last one?
         const isLastBlock = subSlot === this.maxNumberOfBlocks;
 
-        this.log.verbose(
+        this.log?.verbose(
           `Can start ${isLastBlock ? 'last block' : 'block'} in sub-slot ${subSlot} with deadline ${deadline}s`,
           { secondsIntoSlot, deadline, timeUntilDeadline, subSlot, maxBlocks: this.maxNumberOfBlocks },
         );
@@ -271,7 +272,7 @@ export class SequencerTimetable {
     }
 
     // No sub-slots available with enough time
-    this.log.verbose(`No time left to start any more blocks`, {
+    this.log?.verbose(`No time left to start any more blocks`, {
       secondsIntoSlot,
       maxBlocks: this.maxNumberOfBlocks,
       initializationOffset: this.initializationOffset,

package/src/sequencer/types.ts

@@ -2,5 +2,5 @@ import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 
 export type SequencerRollupConstants = Pick<
   L1RollupConstants,
-  'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration'
+  'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration' | 'rollupManaLimit'
 >;

package/src/test/index.ts

@@ -1,18 +1,16 @@
-import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import type { PublisherManager } from '@aztec/ethereum/publisher-manager';
 import type { PublicProcessorFactory } from '@aztec/simulator/server';
 import type { FullNodeCheckpointsBuilder, ValidatorClient } from '@aztec/validator-client';
 
 import { SequencerClient } from '../client/sequencer-client.js';
 import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
-import type { SequencerPublisher } from '../publisher/sequencer-publisher.js';
 import { Sequencer } from '../sequencer/sequencer.js';
 import type { SequencerTimetable } from '../sequencer/timetable.js';
 
 class TestSequencer_ extends Sequencer {
   declare public publicProcessorFactory: PublicProcessorFactory;
   declare public timetable: SequencerTimetable;
-  declare public publisher: SequencerPublisher;
   declare public publisherFactory: SequencerPublisherFactory;
   declare public validatorClient: ValidatorClient;
   declare public checkpointsBuilder: FullNodeCheckpointsBuilder;
@@ -22,7 +20,7 @@ export type TestSequencer = TestSequencer_;
 
 class TestSequencerClient_ extends SequencerClient {
   declare public sequencer: TestSequencer;
-  declare public publisherManager: PublisherManager<L1TxUtilsWithBlobs>;
+  declare public publisherManager: PublisherManager<L1TxUtils>;
 }
 
 export type TestSequencerClient = TestSequencerClient_;

package/src/test/mock_checkpoint_builder.ts

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

package/src/test/utils.ts

@@ -56,6 +56,7 @@ export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Pr
 export function mockPendingTxs(p2p: MockProxy<P2P>, txs: Tx[]): void {
   p2p.getPendingTxCount.mockResolvedValue(txs.length);
   p2p.iteratePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
+  p2p.iterateEligiblePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
 }
 
 /**
@@ -118,10 +119,11 @@ export function createCheckpointProposal(
   block: L2Block,
   checkpointSignature: Signature,
   blockSignature?: Signature,
+  feeAssetPriceModifier: bigint = 0n,
 ): CheckpointProposal {
   const txHashes = block.body.txEffects.map(tx => tx.txHash);
   const checkpointHeader = createCheckpointHeaderFromBlock(block);
-  return new CheckpointProposal(checkpointHeader, block.archive.root, checkpointSignature, {
+  return new CheckpointProposal(checkpointHeader, block.archive.root, feeAssetPriceModifier, checkpointSignature, {
     blockHeader: block.header,
     indexWithinCheckpoint: block.indexWithinCheckpoint,
     txHashes,
@@ -138,9 +140,10 @@ export function createCheckpointAttestation(
   block: L2Block,
   signature: Signature,
   sender: EthAddress,
+  feeAssetPriceModifier: bigint = 0n,
 ): CheckpointAttestation {
   const checkpointHeader = createCheckpointHeaderFromBlock(block);
-  const payload = new ConsensusPayload(checkpointHeader, block.archive.root);
+  const payload = new ConsensusPayload(checkpointHeader, block.archive.root, feeAssetPriceModifier);
   const attestation = new CheckpointAttestation(payload, signature, signature);
   // Set sender directly for testing (bypasses signature recovery)
   (attestation as any).sender = sender;