@aztec/sequencer-client 0.0.1-commit.f295ac2 → 0.0.1-commit.f2ce05ee

package/src/test/mock_checkpoint_builder.ts

@@ -1,11 +1,9 @@
 import { type BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { Timer } from '@aztec/foundation/timer';
-import { L2BlockNew } from '@aztec/stdlib/block';
+import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { Gas } from '@aztec/stdlib/gas';
 import type {
-  BuildBlockInCheckpointResult,
   FullNodeBlockBuilderConfig,
   ICheckpointBlockBuilder,
   ICheckpointsBuilder,
@@ -15,19 +13,20 @@ import type {
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
 import type { CheckpointGlobalVariables, Tx } from '@aztec/stdlib/tx';
+import type { BuildBlockInCheckpointResult } from '@aztec/validator-client';
 
 /**
  * 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 ICheckpointBlockBuilder {
-  private blocks: L2BlockNew[] = [];
-  private builtBlocks: L2BlockNew[] = [];
+  private blocks: L2Block[] = [];
+  private builtBlocks: L2Block[] = [];
   private usedTxsPerBlock: Tx[][] = [];
   private blockIndex = 0;
 
   /** Optional function to dynamically provide the block (alternative to seedBlocks) */
-  private blockProvider: (() => L2BlockNew) | undefined = undefined;
+  private blockProvider: (() => L2Block) | undefined = undefined;
 
   /** Track calls for assertions */
   public buildBlockCalls: Array<{
@@ -35,6 +34,8 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
     timestamp: bigint;
     opts: PublicProcessorLimits;
   }> = [];
+  /** Track all consumed transaction hashes across buildBlock calls */
+  public consumedTxHashes: Set<string> = new Set();
   public completeCheckpointCalled = false;
   public getCheckpointCalled = false;
 
@@ -47,7 +48,7 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
   ) {}
 
   /** Seed the builder with blocks to return on successive buildBlock calls */
-  seedBlocks(blocks: L2BlockNew[], usedTxsPerBlock?: Tx[][]): this {
+  seedBlocks(blocks: L2Block[], usedTxsPerBlock?: Tx[][]): this {
     this.blocks = blocks;
     this.usedTxsPerBlock = usedTxsPerBlock ?? blocks.map(() => []);
     this.blockIndex = 0;
@@ -59,7 +60,7 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
    * 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 {
+  setBlockProvider(provider: () => L2Block): this {
     this.blockProvider = provider;
     this.blocks = [];
     return this;
@@ -69,8 +70,8 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
     return this.constants;
   }
 
-  buildBlock(
-    _pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
     blockNumber: BlockNumber,
     timestamp: bigint,
     opts: PublicProcessorLimits,
@@ -78,10 +79,10 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
     this.buildBlockCalls.push({ blockNumber, timestamp, opts });
 
     if (this.errorOnBuild) {
-      return Promise.reject(this.errorOnBuild);
+      throw this.errorOnBuild;
     }
 
-    let block: L2BlockNew;
+    let block: L2Block;
     let usedTxs: Tx[];
 
     if (this.blockProvider) {
@@ -97,16 +98,28 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
       this.builtBlocks.push(block);
     }
 
-    return Promise.resolve({
+    // Check that no pending tx has already been consumed
+    for await (const tx of pendingTxs) {
+      const hash = tx.getTxHash().toString();
+      if (this.consumedTxHashes.has(hash)) {
+        throw new Error(`Transaction ${hash} was already consumed in a previous block`);
+      }
+    }
+
+    // Add used txs to consumed set
+    for (const tx of usedTxs) {
+      this.consumedTxHashes.add(tx.getTxHash().toString());
+    }
+
+    return {
       block,
       publicGas: Gas.empty(),
       publicProcessorDuration: 0,
       numTxs: block?.body?.txEffects?.length ?? usedTxs.length,
-      blockBuildingTimer: new Timer(),
       usedTxs,
       failedTxs: [],
       usedTxBlobFields: block?.body?.txEffects?.reduce((sum, tx) => sum + tx.getNumBlobFields(), 0) ?? 0,
-    });
+    };
   }
 
   completeCheckpoint(): Promise<Checkpoint> {
@@ -148,7 +161,7 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
    * 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 {
+  private createCheckpointHeader(block: L2Block): CheckpointHeader {
     const header = block.header;
     const gv = header.globalVariables;
     return CheckpointHeader.empty({
@@ -170,6 +183,7 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
     this.usedTxsPerBlock = [];
     this.blockIndex = 0;
     this.buildBlockCalls = [];
+    this.consumedTxHashes.clear();
     this.completeCheckpointCalled = false;
     this.getCheckpointCalled = false;
     this.errorOnBuild = undefined;
@@ -197,7 +211,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
     constants: CheckpointGlobalVariables;
     l1ToL2Messages: Fr[];
     previousCheckpointOutHashes: Fr[];
-    existingBlocks: L2BlockNew[];
+    existingBlocks: L2Block[];
   }> = [];
   public updateConfigCalls: Array<Partial<FullNodeBlockBuilderConfig>> = [];
 
@@ -263,7 +277,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
     _fork: MerkleTreeWriteOperations,
-    existingBlocks: L2BlockNew[] = [],
+    existingBlocks: L2Block[] = [],
   ): Promise<ICheckpointBlockBuilder> {
     this.openCheckpointCalls.push({
       checkpointNumber,

package/src/test/utils.ts

@@ -7,7 +7,7 @@ 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 { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
 import { BlockProposal, CheckpointAttestation, CheckpointProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { makeAppendOnlyTreeSnapshot, mockTxForRollup } from '@aztec/stdlib/testing';
@@ -30,9 +30,9 @@ export async function makeTx(seed?: number, chainId?: Fr): Promise<Tx> {
 }
 
 /**
- * Creates an L2BlockNew from transactions and global variables
+ * Creates an L2Block from transactions and global variables
  */
-export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Promise<L2BlockNew> {
+export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Promise<L2Block> {
   const processedTxs = await Promise.all(
     txs.map(tx =>
       makeProcessedTxFromPrivateOnlyTx(tx, Fr.ZERO, new PublicDataWrite(Fr.random(), Fr.random()), globalVariables),
@@ -41,7 +41,13 @@ export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Pr
   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), IndexWithinCheckpoint(0));
+  return new L2Block(
+    archive,
+    header,
+    body,
+    CheckpointNumber.fromBlockNumber(globalVariables.blockNumber),
+    IndexWithinCheckpoint(0),
+  );
 }
 
 /**
@@ -70,10 +76,10 @@ export function createMockSignatures(signer: Secp256k1Signer): CommitteeAttestat
 }
 
 /**
- * Creates a CheckpointHeader from an L2BlockNew for testing purposes.
- * Uses mock values for blockHeadersHash, blobsHash and inHash since L2BlockNew doesn't have these fields.
+ * Creates a CheckpointHeader from an L2Block for testing purposes.
+ * Uses mock values for blockHeadersHash, blobsHash and inHash since L2Block doesn't have these fields.
  */
-function createCheckpointHeaderFromBlock(block: L2BlockNew): CheckpointHeader {
+function createCheckpointHeaderFromBlock(block: L2Block): CheckpointHeader {
   const gv = block.header.globalVariables;
   return new CheckpointHeader(
     block.header.lastArchive.root,
@@ -93,7 +99,7 @@ function createCheckpointHeaderFromBlock(block: L2BlockNew): CheckpointHeader {
 /**
  * Creates a block proposal from a block and signature
  */
-export function createBlockProposal(block: L2BlockNew, signature: Signature): BlockProposal {
+export function createBlockProposal(block: L2Block, signature: Signature): BlockProposal {
   const txHashes = block.body.txEffects.map(tx => tx.txHash);
   return new BlockProposal(
     block.header,
@@ -109,7 +115,7 @@ export function createBlockProposal(block: L2BlockNew, signature: Signature): Bl
  * Creates a checkpoint proposal from a block and signature
  */
 export function createCheckpointProposal(
-  block: L2BlockNew,
+  block: L2Block,
   checkpointSignature: Signature,
   blockSignature?: Signature,
 ): CheckpointProposal {
@@ -129,7 +135,7 @@ export function createCheckpointProposal(
  * In production, the sender is recovered from the signature.
  */
 export function createCheckpointAttestation(
-  block: L2BlockNew,
+  block: L2Block,
   signature: Signature,
   sender: EthAddress,
 ): CheckpointAttestation {
@@ -150,7 +156,7 @@ export async function setupTxsAndBlock(
   globalVariables: GlobalVariables,
   txCount: number,
   chainId: Fr,
-): Promise<{ txs: Tx[]; block: L2BlockNew }> {
+): Promise<{ txs: Tx[]; block: L2Block }> {
   const txs = await Promise.all(times(txCount, i => makeTx(i + 1, chainId)));
   const block = await makeBlock(txs, globalVariables);
   mockPendingTxs(p2p, txs);