@aztec/sequencer-client 0.0.1-commit.d431d1c → 0.0.1-commit.e310a4c8

package/src/sequencer/checkpoint_proposal_job.ts

@@ -1,22 +1,28 @@
 import { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec/blob-lib/encoding';
 import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
 import type { EpochCache } from '@aztec/epoch-cache';
-import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  EpochNumber,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { filter } from '@aztec/foundation/iterator';
-import type { Logger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { sleep, sleepUntil } from '@aztec/foundation/sleep';
 import { type DateProvider, Timer } from '@aztec/foundation/timer';
-import { type TypedEventEmitter, unfreeze } from '@aztec/foundation/types';
+import { type TypedEventEmitter, isErrorClass, unfreeze } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
 import {
   CommitteeAttestation,
   CommitteeAttestationsAndSigners,
-  L2BlockNew,
+  L2Block,
   type L2BlockSink,
   type L2BlockSource,
   MaliciousCommitteeAttestationsAndSigners,
@@ -24,10 +30,11 @@ import {
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
-import type {
-  PublicProcessorLimits,
-  ResolvedSequencerConfig,
-  WorldStateSynchronizer,
+import {
+  NoValidTxsError,
+  type PublicProcessorLimits,
+  type ResolvedSequencerConfig,
+  type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
 import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import type { BlockProposalOptions, CheckpointProposal, CheckpointProposalOptions } from '@aztec/stdlib/p2p';
@@ -59,6 +66,8 @@ const TXS_POLLING_MS = 500;
  * the Sequencer once the check for being the proposer for the slot has succeeded.
  */
 export class CheckpointProposalJob implements Traceable {
+  protected readonly log: Logger;
+
   constructor(
     private readonly epoch: EpochNumber,
     private readonly slot: SlotNumber,
@@ -86,9 +95,11 @@ export class CheckpointProposalJob implements Traceable {
     private readonly metrics: SequencerMetrics,
     private readonly eventEmitter: TypedEventEmitter<SequencerEvents>,
     private readonly setStateFn: (state: SequencerState, slot?: SlotNumber) => void,
-    protected readonly log: Logger,
     public readonly tracer: Tracer,
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('sequencer:checkpoint-proposal', { ...bindings, instanceId: `slot-${slot}` });
+  }
 
   /**
    * Executes the checkpoint proposal job.
@@ -190,6 +201,7 @@ export class CheckpointProposalJob implements Traceable {
         l1ToL2Messages,
         previousCheckpointOutHashes,
         fork,
+        this.log.getBindings(),
       );
 
       // Options for the validator client when creating block and checkpoint proposals
@@ -203,8 +215,8 @@ export class CheckpointProposalJob implements Traceable {
         broadcastInvalidCheckpointProposal: this.config.broadcastInvalidBlockProposal,
       };
 
-      let blocksInCheckpoint: L2BlockNew[] = [];
-      let blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
+      let blocksInCheckpoint: L2Block[] = [];
+      let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
 
       try {
         // Main loop: build blocks for the checkpoint
@@ -352,10 +364,10 @@ export class CheckpointProposalJob implements Traceable {
     inHash: Fr,
     blockProposalOptions: BlockProposalOptions,
   ): Promise<{
-    blocksInCheckpoint: L2BlockNew[];
-    blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined;
+    blocksInCheckpoint: L2Block[];
+    blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined;
   }> {
-    const blocksInCheckpoint: L2BlockNew[] = [];
+    const blocksInCheckpoint: L2Block[] = [];
     const txHashesAlreadyIncluded = new Set<string>();
     const initialBlockNumber = BlockNumber(this.syncedToBlockNumber + 1);
 
@@ -363,11 +375,11 @@ export class CheckpointProposalJob implements Traceable {
     let remainingBlobFields = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
 
     // Last block in the checkpoint will usually be flagged as pending broadcast, so we send it along with the checkpoint proposal
-    let blockPendingBroadcast: { block: L2BlockNew; txs: Tx[] } | undefined = undefined;
+    let blockPendingBroadcast: { block: L2Block; txs: Tx[] } | undefined = undefined;
 
     while (true) {
       const blocksBuilt = blocksInCheckpoint.length;
-      const indexWithinCheckpoint = blocksBuilt;
+      const indexWithinCheckpoint = IndexWithinCheckpoint(blocksBuilt);
       const blockNumber = BlockNumber(initialBlockNumber + blocksBuilt);
 
       const secondsIntoSlot = this.getSecondsIntoSlot();
@@ -397,6 +409,7 @@ export class CheckpointProposalJob implements Traceable {
         remainingBlobFields,
       });
 
+      // TODO(palla/mbps): Review these conditions. We may want to keep trying in some scenarios.
       if (!buildResult && timingInfo.isLastBlock) {
         // If no block was produced due to not enough txs and this was the last subslot, exit
         break;
@@ -428,7 +441,12 @@ export class CheckpointProposalJob implements Traceable {
       // Sync the proposed block to the archiver to make it available
       // Note that the checkpoint builder uses its own fork so it should not need to wait for this syncing
       // Eventually we should refactor the checkpoint builder to not need a separate long-lived fork
-      await this.syncProposedBlockToArchiver(block);
+      // Fire and forget - don't block the critical path, but log errors
+      this.syncProposedBlockToArchiver(block).catch(err => {
+        this.log.error(`Failed to sync proposed block ${block.number} to archiver`, { blockNumber: block.number, err });
+      });
+
+      usedTxs.forEach(tx => txHashesAlreadyIncluded.add(tx.txHash.toString()));
 
       // If this is the last block, exit the loop now so we start collecting attestations
       if (timingInfo.isLastBlock) {
@@ -478,18 +496,18 @@ export class CheckpointProposalJob implements Traceable {
 
   /** Builds a single block. Called from the main block building loop. */
   @trackSpan('CheckpointProposalJob.buildSingleBlock')
-  private async buildSingleBlock(
+  protected async buildSingleBlock(
     checkpointBuilder: CheckpointBuilder,
     opts: {
       forceCreate?: boolean;
       blockTimestamp: bigint;
       blockNumber: BlockNumber;
-      indexWithinCheckpoint: number;
+      indexWithinCheckpoint: IndexWithinCheckpoint;
       buildDeadline: Date | undefined;
       txHashesAlreadyIncluded: Set<string>;
       remainingBlobFields: number;
     },
-  ): Promise<{ block: L2BlockNew; usedTxs: Tx[]; remainingBlobFields: number } | { error: Error } | undefined> {
+  ): Promise<{ block: L2Block; usedTxs: Tx[]; remainingBlobFields: number } | { error: Error } | undefined> {
     const {
       blockTimestamp,
       forceCreate,
@@ -545,45 +563,38 @@ export class CheckpointProposalJob implements Traceable {
       };
 
       // Actually build the block by executing txs
-      const workTimer = new Timer();
-      const {
-        publicGas,
-        block,
-        publicProcessorDuration,
-        numTxs,
-        blockBuildingTimer,
-        usedTxs,
-        failedTxs,
-        usedTxBlobFields,
-      } = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
-      const blockBuildDuration = workTimer.ms();
+      const buildResult = await this.buildSingleBlockWithCheckpointBuilder(
+        checkpointBuilder,
+        pendingTxs,
+        blockNumber,
+        blockTimestamp,
+        blockBuilderOptions,
+      );
 
       // If any txs failed during execution, drop them from the mempool so we don't pick them up again
-      await this.dropFailedTxsFromP2P(failedTxs);
+      await this.dropFailedTxsFromP2P(buildResult.failedTxs);
 
       // Check if we have created a block with enough txs. If there were invalid txs in the pool, or if execution took
       // too long, then we may not get to minTxsPerBlock after executing public functions.
       const minValidTxs = this.config.minValidTxsPerBlock ?? minTxs;
-      if (!forceCreate && numTxs < minValidTxs) {
+      const numTxs = buildResult.status === 'no-valid-txs' ? 0 : buildResult.numTxs;
+      if (buildResult.status === 'no-valid-txs' || (!forceCreate && numTxs < minValidTxs)) {
         this.log.warn(
-          `Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed (got ${numTxs} but required ${minValidTxs})`,
-          { slot: this.slot, blockNumber, numTxs, indexWithinCheckpoint },
+          `Block ${blockNumber} at index ${indexWithinCheckpoint} on slot ${this.slot} has too few valid txs to be proposed`,
+          { slot: this.slot, blockNumber, numTxs, indexWithinCheckpoint, minValidTxs, buildResult: buildResult.status },
         );
-        this.eventEmitter.emit('block-tx-count-check-failed', {
-          minTxs: minValidTxs,
-          availableTxs: numTxs,
-          slot: this.slot,
-        });
+        this.eventEmitter.emit('block-build-failed', { reason: `Insufficient valid txs`, slot: this.slot });
         this.metrics.recordBlockProposalFailed('insufficient_valid_txs');
         return undefined;
       }
 
       // Block creation succeeded, emit stats and metrics
+      const { publicGas, block, publicProcessorDuration, usedTxs, usedTxBlobFields, blockBuildDuration } = buildResult;
+
       const blockStats = {
         eventName: 'l2-block-built',
         duration: blockBuildDuration,
         publicProcessDuration: publicProcessorDuration,
-        rollupCircuitsDuration: blockBuildingTimer.ms(),
         ...block.getStats(),
       } satisfies L2BlockBuiltStats;
 
@@ -609,17 +620,40 @@ export class CheckpointProposalJob implements Traceable {
     }
   }
 
+  /** Uses the checkpoint builder to build a block, catching specific txs */
+  private async buildSingleBlockWithCheckpointBuilder(
+    checkpointBuilder: CheckpointBuilder,
+    pendingTxs: AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    blockTimestamp: bigint,
+    blockBuilderOptions: PublicProcessorLimits,
+  ) {
+    try {
+      const workTimer = new Timer();
+      const result = await checkpointBuilder.buildBlock(pendingTxs, blockNumber, blockTimestamp, blockBuilderOptions);
+      const blockBuildDuration = workTimer.ms();
+      return { ...result, blockBuildDuration, status: 'success' as const };
+    } catch (err: unknown) {
+      if (isErrorClass(err, NoValidTxsError)) {
+        return { failedTxs: err.failedTxs, status: 'no-valid-txs' as const };
+      }
+      throw err;
+    }
+  }
+
   /** Waits until minTxs are available on the pool for building a block. */
   @trackSpan('CheckpointProposalJob.waitForMinTxs')
   private async waitForMinTxs(opts: {
     forceCreate?: boolean;
     blockNumber: BlockNumber;
-    indexWithinCheckpoint: number;
+    indexWithinCheckpoint: IndexWithinCheckpoint;
     buildDeadline: Date | undefined;
   }): Promise<{ canStartBuilding: boolean; availableTxs: number }> {
-    const minTxs = this.config.minTxsPerBlock;
     const { indexWithinCheckpoint, blockNumber, buildDeadline, forceCreate } = opts;
 
+    // We only allow a block with 0 txs in the first block of the checkpoint
+    const minTxs = indexWithinCheckpoint > 0 && this.config.minTxsPerBlock === 0 ? 1 : this.config.minTxsPerBlock;
+
     // Deadline is undefined if we are not enforcing the timetable, meaning we'll exit immediately when out of time
     const startBuildingDeadline = buildDeadline
       ? new Date(buildDeadline.getTime() - this.timetable.minExecutionTime * 1000)
@@ -681,7 +715,7 @@ export class CheckpointProposalJob implements Traceable {
     const attestationTimeAllowed = this.config.enforceTimeTable
       ? this.timetable.getMaxAllowedTime(SequencerState.PUBLISHING_CHECKPOINT)!
       : this.l1Constants.slotDuration;
-    const attestationDeadline = new Date(this.dateProvider.now() + attestationTimeAllowed * 1000);
+    const attestationDeadline = new Date((this.getSlotStartBuildTimestamp() + attestationTimeAllowed) * 1000);
 
     this.metrics.recordRequiredAttestations(numberOfRequiredAttestations, attestationTimeAllowed);
 
@@ -777,8 +811,7 @@ export class CheckpointProposalJob implements Traceable {
    * Gossip doesn't echo messages back to the sender, so the proposer's archiver/world-state
    * would never receive its own block without this explicit sync.
    */
-  private async syncProposedBlockToArchiver(block: L2BlockNew): Promise<void> {
-    // TODO(palla/mbps): Change default to false once block sync is stable.
+  private async syncProposedBlockToArchiver(block: L2Block): Promise<void> {
     if (this.config.skipPushProposedBlocksToArchiver !== false) {
       this.log.warn(`Skipping push of proposed block ${block.number} to archiver`, {
         blockNumber: block.number,

package/src/sequencer/metrics.ts

@@ -11,6 +11,7 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import { type Hex, formatUnits } from 'viem';
@@ -67,7 +68,9 @@ export class SequencerMetrics {
     this.meter = client.getMeter(name);
     this.tracer = client.getTracer(name);
 
-    this.blockCounter = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
+    this.blockCounter = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_COUNT, {
+      [Attributes.STATUS]: ['failed', 'built'],
+    });
 
     this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION);
 
@@ -77,23 +80,15 @@ export class SequencerMetrics {
 
     this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
 
-    // Init gauges and counters
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'failed',
-    });
-    this.blockCounter.add(0, {
-      [Attributes.STATUS]: 'built',
-    });
-
     this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS);
 
-    this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT);
+    this.slots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLOT_COUNT);
 
     /**
      * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
      * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
      */
-    this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT);
+    this.filledSlots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_FILLED_SLOT_COUNT);
 
     this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION);
 
@@ -103,20 +98,41 @@ export class SequencerMetrics {
 
     this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT);
 
-    this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT);
+    this.blockProposalFailed = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT,
+    );
 
-    this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT);
+    this.blockProposalSuccess = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT,
+    );
 
-    this.checkpointSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
+    this.checkpointSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
 
-    this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(
+    this.blockProposalPrecheckFailed = createUpDownCounterWithDefault(
+      this.meter,
       Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT,
+      {
+        [Attributes.ERROR_TYPE]: [
+          'slot_already_taken',
+          'rollup_contract_check_failed',
+          'slot_mismatch',
+          'block_number_mismatch',
+        ],
+      },
     );
 
-    this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
+    this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
 
     // Fisherman fee analysis metrics
-    this.fishermanWouldBeIncluded = this.meter.createUpDownCounter(Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED);
+    this.fishermanWouldBeIncluded = createUpDownCounterWithDefault(
+      this.meter,
+      Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED,
+      {
+        [Attributes.OK]: [true, false],
+      },
+    );
 
     this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK);
 
@@ -231,7 +247,9 @@ export class SequencerMetrics {
     this.blockProposalSuccess.add(1);
   }
 
-  recordBlockProposalPrecheckFailed(checkType: string) {
+  recordBlockProposalPrecheckFailed(
+    checkType: 'slot_already_taken' | 'rollup_contract_check_failed' | 'slot_mismatch' | 'block_number_mismatch',
+  ) {
     this.blockProposalPrecheckFailed.add(1, {
       [Attributes.ERROR_TYPE]: checkType,
     });

package/src/sequencer/sequencer.ts

@@ -12,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 { L2BlockNew, L2BlockSink, L2BlockSource, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { L2Block, L2BlockSink, L2BlockSource, ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import {
@@ -424,8 +424,8 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       this.metrics,
       this,
       this.setState.bind(this),
-      this.log,
       this.tracer,
+      this.log.getBindings(),
     );
   }
 
@@ -529,7 +529,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       };
     }
 
-    const block = await this.l2BlockSource.getL2BlockNew(blockNumber);
+    const block = await this.l2BlockSource.getL2Block(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`);
@@ -870,7 +870,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
 }
 
 type SequencerSyncCheckResult = {
-  block?: L2BlockNew;
+  block?: L2Block;
   checkpointNumber: CheckpointNumber;
   blockNumber: BlockNumber;
   archive: Fr;

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);