@aztec/sequencer-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

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 = [];
+  }
+}

package/src/test/utils.ts

@@ -0,0 +1,137 @@
+import { Body } from '@aztec/aztec.js/block';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
+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 { PublicDataWrite } from '@aztec/stdlib/avm';
+import { CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
+import { BlockAttestation, BlockProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot, mockTxForRollup } from '@aztec/stdlib/testing';
+import {
+  BlockHeader,
+  ContentCommitment,
+  GlobalVariables,
+  type Tx,
+  makeProcessedTxFromPrivateOnlyTx,
+} from '@aztec/stdlib/tx';
+
+import type { MockProxy } from 'jest-mock-extended';
+
+// Re-export mock classes from their dedicated file
+export { MockCheckpointBuilder, MockCheckpointsBuilder } from './mock_checkpoint_builder.js';
+
+/**
+ * Creates a mock transaction with a specific seed for deterministic testing
+ */
+export async function makeTx(seed?: number, chainId?: Fr): Promise<Tx> {
+  const tx = await mockTxForRollup(seed);
+  if (chainId) {
+    tx.data.constants.txContext.chainId = chainId;
+  }
+  return tx;
+}
+
+/**
+ * Creates an L2BlockNew from transactions and global variables
+ */
+export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Promise<L2BlockNew> {
+  const processedTxs = await Promise.all(
+    txs.map(tx =>
+      makeProcessedTxFromPrivateOnlyTx(tx, Fr.ZERO, new PublicDataWrite(Fr.random(), Fr.random()), globalVariables),
+    ),
+  );
+  const body = new Body(processedTxs.map(tx => tx.txEffect));
+  const header = BlockHeader.empty({ globalVariables });
+  const archive = makeAppendOnlyTreeSnapshot(globalVariables.blockNumber + 1);
+  return new L2BlockNew(archive, header, body, CheckpointNumber(globalVariables.blockNumber), 0);
+}
+
+/**
+ * Mocks the P2P client to return specific pending transactions
+ */
+export function mockPendingTxs(p2p: MockProxy<P2P>, txs: Tx[]): void {
+  p2p.getPendingTxCount.mockResolvedValue(txs.length);
+  p2p.iteratePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
+}
+
+/**
+ * Creates an async iterator for transactions
+ */
+export async function* mockTxIterator(txs: Promise<Tx[]>): AsyncIterableIterator<Tx> {
+  for (const tx of await txs) {
+    yield tx;
+  }
+}
+
+/**
+ * Creates mock committee attestations from a signer
+ */
+export function createMockSignatures(signer: Secp256k1Signer): CommitteeAttestation[] {
+  const mockedSig = Signature.random();
+  return [new CommitteeAttestation(signer.address, mockedSig)];
+}
+
+/**
+ * Creates a CheckpointHeader from an L2BlockNew for testing purposes.
+ * Uses mock values for contentCommitment and blockHeadersHash since
+ * L2BlockNew doesn't have these fields.
+ */
+function createCheckpointHeaderFromBlock(block: L2BlockNew): CheckpointHeader {
+  const gv = block.header.globalVariables;
+  return new CheckpointHeader(
+    block.header.lastArchive.root,
+    Fr.random(), // blockHeadersHash - mock value for testing
+    ContentCommitment.empty(), // contentCommitment - mock value for testing
+    gv.slotNumber,
+    gv.timestamp,
+    gv.coinbase,
+    gv.feeRecipient,
+    gv.gasFees,
+    block.header.totalManaUsed,
+  );
+}
+
+/**
+ * Creates a block proposal from a block and signature
+ */
+export function createBlockProposal(block: L2BlockNew, signature: Signature): BlockProposal {
+  const checkpointHeader = createCheckpointHeaderFromBlock(block);
+  const consensusPayload = new ConsensusPayload(checkpointHeader, block.archive.root);
+  const txHashes = block.body.txEffects.map(tx => tx.txHash);
+  return new BlockProposal(consensusPayload, signature, txHashes);
+}
+
+/**
+ * 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 function createBlockAttestation(block: L2BlockNew, signature: Signature, sender: EthAddress): BlockAttestation {
+  const checkpointHeader = createCheckpointHeaderFromBlock(block);
+  const consensusPayload = new ConsensusPayload(checkpointHeader, block.archive.root);
+  const attestation = new BlockAttestation(consensusPayload, signature, signature);
+  // Set sender directly for testing (bypasses signature recovery)
+
+  (attestation as any).sender = sender;
+  return attestation;
+}
+
+/**
+ * Creates transactions and a block, and mocks P2P to return them.
+ * Helper for tests that need to set up a block with transactions.
+ */
+export async function setupTxsAndBlock(
+  p2p: MockProxy<P2P>,
+  globalVariables: GlobalVariables,
+  txCount: number,
+  chainId: Fr,
+): Promise<{ txs: Tx[]; block: L2BlockNew }> {
+  const txs = await Promise.all(times(txCount, i => makeTx(i + 1, chainId)));
+  const block = await makeBlock(txs, globalVariables);
+  mockPendingTxs(p2p, txs);
+  return { txs, block };
+}

package/src/tx_validator/tx_validator_factory.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import {
   AggregateTxValidator,
@@ -9,10 +10,11 @@ import {
   GasTxValidator,
   MetadataTxValidator,
   PhasesTxValidator,
+  TimestampTxValidator,
   TxPermittedValidator,
   TxProofValidator,
 } from '@aztec/p2p';
-import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { ProtocolContractAddress, protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { GasFees } from '@aztec/stdlib/gas';
 import type {
@@ -47,7 +49,7 @@ export function createValidatorForAcceptingTxs(
     gasFees: GasFees;
     skipFeeEnforcement?: boolean;
     timestamp: UInt64;
-    blockNumber: number;
+    blockNumber: BlockNumber;
     txsPermitted: boolean;
   },
 ): TxValidator<Tx> {
@@ -57,10 +59,12 @@ export function createValidatorForAcceptingTxs(
     new MetadataTxValidator({
       l1ChainId: new Fr(l1ChainId),
       rollupVersion: new Fr(rollupVersion),
+      protocolContractsHash,
+      vkTreeRoot: getVKTreeRoot(),
+    }),
+    new TimestampTxValidator({
       timestamp,
       blockNumber,
-      protocolContractTreeRoot,
-      vkTreeRoot: getVKTreeRoot(),
     }),
     new DoubleSpendTxValidator(new NullifierCache(db)),
     new PhasesTxValidator(contractDataSource, setupAllowList, timestamp),
@@ -114,10 +118,12 @@ function preprocessValidator(
     new MetadataTxValidator({
       l1ChainId: globalVariables.chainId,
       rollupVersion: globalVariables.version,
+      protocolContractsHash,
+      vkTreeRoot: getVKTreeRoot(),
+    }),
+    new TimestampTxValidator({
       timestamp: globalVariables.timestamp,
       blockNumber: globalVariables.blockNumber,
-      protocolContractTreeRoot,
-      vkTreeRoot: getVKTreeRoot(),
     }),
     new DoubleSpendTxValidator(nullifierCache),
     new PhasesTxValidator(contractDataSource, setupAllowList, globalVariables.timestamp),