Merge branch 'next' into merge-train/barretenberg

Author: AztecBot

yarn-project/foundation/src/types/index.test.ts

@@ -0,0 +1,36 @@
+import { isErrorClass } from './index.js';
+
+describe('isErrorClass', () => {
+  class CustomError extends Error {
+    constructor() {
+      super('This is a custom error');
+      this.name = 'CustomError';
+    }
+  }
+
+  class AnotherError extends Error {
+    constructor() {
+      super('This is a another error');
+      this.name = 'AnotherError';
+    }
+  }
+
+  it('should identify instances of the specified error class', () => {
+    const error = new CustomError();
+    expect(isErrorClass(error, CustomError)).toBe(true);
+    expect(isErrorClass(error, AnotherError)).toBe(false);
+  });
+
+  it('should handle non-error values correctly', () => {
+    expect(isErrorClass({}, CustomError)).toBe(false);
+    expect(isErrorClass(null, CustomError)).toBe(false);
+    expect(isErrorClass(undefined, CustomError)).toBe(false);
+    expect(isErrorClass('error', CustomError)).toBe(false);
+  });
+
+  it('should identify built-in Error instances', () => {
+    const error = new Error('Built-in error');
+    expect(isErrorClass(error, Error)).toBe(true);
+    expect(isErrorClass(error, CustomError)).toBe(false);
+  });
+});

yarn-project/foundation/src/types/index.ts

@@ -24,6 +24,11 @@ export function isDefined<T>(value: T | undefined): value is T {
   return value !== undefined;
 }
 
+/** Type guard for error classes */
+export function isErrorClass<T extends Error>(value: unknown, errorClass: new (...args: any[]) => T): value is T {
+  return value instanceof errorClass || (value instanceof Error && value.name === errorClass.name);
+}
+
 /** Resolves a record-like type. Lifted from viem. */
 export type Prettify<T> = {
   [K in keyof T]: T[K];

…src/sequencer/checkpoint_builder.test.ts …t/lightweight_checkpoint_builder.test.tsyarn-project/sequencer-client/src/sequencer/checkpoint_builder.test.ts renamed to yarn-project/prover-client/src/light/lightweight_checkpoint_builder.test.ts yarn-project/sequencer-client/src/sequencer/checkpoint_builder.test.ts renamed to yarn-project/prover-client/src/light/lightweight_checkpoint_builder.test.ts

@@ -5,7 +5,6 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractsList, protocolContractsHash } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
-import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { EthAddress } from '@aztec/stdlib/block';
@@ -20,7 +19,9 @@ import { NativeWorldStateService } from '@aztec/world-state/native';
 
 import { afterEach, beforeEach, describe, expect, it } from '@jest/globals';
 
-describe('CheckpointBuilder', () => {
+import { LightweightCheckpointBuilder } from './lightweight_checkpoint_builder.js';
+
+describe('LightweightCheckpointBuilder', () => {
   let worldState: NativeWorldStateService;
   let feePayer: AztecAddress;
   let feePayerBalance: Fr;

yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts

@@ -143,6 +143,11 @@ export class LightweightCheckpointBuilder {
     return builder;
   }
 
+  /** Returns how many blocks have been added to this checkpoint so far */
+  public getBlockCount() {
+    return this.blocks.length;
+  }
+
   /**
    * Adds a new block to the checkpoint. The tx effects must have already been inserted into the db if
    * this is called after tx processing, if that's not the case, then set `insertTxsEffects` to true.

yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts

@@ -23,21 +23,23 @@ import type { TypedEventEmitter } from '@aztec/foundation/types';
 import { type P2P, P2PClientState } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CommitteeAttestation, type L2BlockSink, type L2BlockSource } from '@aztec/stdlib/block';
+import { CommitteeAttestation, L2Block, type L2BlockSink, type L2BlockSource } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
-import type {
-  MerkleTreeWriteOperations,
-  ResolvedSequencerConfig,
-  WorldStateSynchronizer,
+import {
+  type BuildBlockInCheckpointResult,
+  type MerkleTreeWriteOperations,
+  NoValidTxsError,
+  type ResolvedSequencerConfig,
+  type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { BlockProposal, CheckpointProposal } from '@aztec/stdlib/p2p';
-import { GlobalVariables, type Tx } from '@aztec/stdlib/tx';
+import { type FailedTx, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { getTelemetryClient } from '@aztec/telemetry-client';
-import type { FullNodeCheckpointsBuilder, ValidatorClient } from '@aztec/validator-client';
+import { CheckpointBuilder, type FullNodeCheckpointsBuilder, type ValidatorClient } from '@aztec/validator-client';
 import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validator-ha-signer/errors';
 import { DutyType } from '@aztec/validator-ha-signer/types';
 
@@ -458,7 +460,7 @@ describe('CheckpointProposalJob', () => {
     const txs = await Promise.all(Array.from({ length: totalTxs }, (_, i) => makeTx(i + 1, chainId)));
 
     // Set up p2p mocks
-    p2p.getPendingTxCount.mockResolvedValue(10);
+    p2p.getPendingTxCount.mockResolvedValue(txs.length);
     p2p.iteratePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
 
     // Create blocks with incrementing block numbers
@@ -585,6 +587,92 @@ describe('CheckpointProposalJob', () => {
       expect(waitSpy.mock.calls[0][0]).toEqual(10);
     });
 
+    it('builds a single empty block when no txs are available and no min txs required', async () => {
+      // Mock timetable to have two sub-slots
+      jest
+        .spyOn(job.getTimetable(), 'canStartNextBlock')
+        .mockReturnValueOnce({ canStart: true, deadline: 2, isLastBlock: false })
+        .mockReturnValueOnce({ canStart: true, deadline: 4, isLastBlock: true })
+        .mockReturnValue({ canStart: false, deadline: undefined, isLastBlock: false });
+
+      // Set up test data for an empty block
+      const { lastBlock } = await setupMultipleBlocks(1, [0]);
+      validatorClient.collectAttestations.mockResolvedValue(getAttestations(lastBlock));
+
+      // Install spy on waitUntilTimeInSlot to verify it's called with expected deadlines
+      const waitSpy = jest.spyOn(job, 'waitUntilTimeInSlot');
+
+      job.updateConfig({ minTxsPerBlock: 0 });
+      const checkpoint = await job.execute();
+
+      expect(checkpoint).toBeDefined();
+      expect(checkpointBuilder.buildBlockCalls).toHaveLength(1);
+      expect(validatorClient.collectAttestations).toHaveBeenCalledTimes(1);
+      expect(publisher.enqueueProposeCheckpoint).toHaveBeenCalledTimes(1);
+
+      // Verify waitUntilTimeInSlot was called between blocks
+      expect(waitSpy).toHaveBeenCalledTimes(1);
+      // The wait time is until the next block deadline
+      expect(waitSpy.mock.calls[0][0]).toEqual(2);
+    });
+
+    it('builds a single block when not enough txs are available but we build empty checkpoints', async () => {
+      // Mock timetable to have two sub-slots
+      jest
+        .spyOn(job.getTimetable(), 'canStartNextBlock')
+        .mockReturnValueOnce({ canStart: true, deadline: 2, isLastBlock: false })
+        .mockReturnValueOnce({ canStart: true, deadline: 4, isLastBlock: true })
+        .mockReturnValue({ canStart: false, deadline: undefined, isLastBlock: false });
+
+      // Set up test data for a block with only 2 txs, note that min txs is 5
+      const { lastBlock } = await setupMultipleBlocks(1, [2]);
+      validatorClient.collectAttestations.mockResolvedValue(getAttestations(lastBlock));
+
+      // Install spy on waitUntilTimeInSlot to verify it's called with expected deadlines
+      const waitSpy = jest.spyOn(job, 'waitUntilTimeInSlot');
+
+      job.updateConfig({ minTxsPerBlock: 5, buildCheckpointIfEmpty: true });
+      const checkpoint = await job.execute();
+
+      expect(checkpoint).toBeDefined();
+      expect(checkpointBuilder.buildBlockCalls).toHaveLength(1);
+      expect(validatorClient.collectAttestations).toHaveBeenCalledTimes(1);
+      expect(publisher.enqueueProposeCheckpoint).toHaveBeenCalledTimes(1);
+
+      // Verify waitUntilTimeInSlot was called between blocks
+      expect(waitSpy).toHaveBeenCalledTimes(1);
+      // The wait time is until the next block deadline
+      expect(waitSpy.mock.calls[0][0]).toEqual(2);
+    });
+
+    it('does not build anything if not enough txs and we do not build empty checkpoints', async () => {
+      // Mock timetable to have two sub-slots
+      jest
+        .spyOn(job.getTimetable(), 'canStartNextBlock')
+        .mockReturnValueOnce({ canStart: true, deadline: 2, isLastBlock: false })
+        .mockReturnValueOnce({ canStart: true, deadline: 4, isLastBlock: true })
+        .mockReturnValue({ canStart: false, deadline: undefined, isLastBlock: false });
+
+      // Not enough txs to build a block
+      p2p.getPendingTxCount.mockResolvedValue(2);
+
+      // Install spy on waitUntilTimeInSlot to verify it's called with expected deadlines
+      const waitSpy = jest.spyOn(job, 'waitUntilTimeInSlot');
+
+      job.updateConfig({ minTxsPerBlock: 5, buildCheckpointIfEmpty: false });
+      const checkpoint = await job.execute();
+
+      expect(checkpoint).toBeUndefined();
+      expect(checkpointBuilder.buildBlockCalls).toHaveLength(0);
+      expect(validatorClient.collectAttestations).toHaveBeenCalledTimes(0);
+      expect(publisher.enqueueProposeCheckpoint).toHaveBeenCalledTimes(0);
+
+      // Verify waitUntilTimeInSlot was called between blocks
+      expect(waitSpy).toHaveBeenCalledTimes(1);
+      // The wait time is until the next block deadline
+      expect(waitSpy.mock.calls[0][0]).toEqual(2);
+    });
+
     it('stops building when canStartNextBlock returns false', async () => {
       // Mock timetable to stop after 1 block (simulating time running out)
       jest
@@ -720,6 +808,53 @@ describe('CheckpointProposalJob', () => {
     });
   });
 
+  describe('build single block', () => {
+    it('does not build a block if not enough valid txs are collected', async () => {
+      // We have enough txs, but not enough valid ones
+      job.updateConfig({ minTxsPerBlock: 3, minValidTxsPerBlock: 2 });
+      const txs = await timesAsync(3, i => makeTx(i + 1, chainId));
+      mockPendingTxs(p2p, txs);
+
+      const checkpointBuilder = mock<CheckpointBuilder>();
+      const failedTxs: FailedTx[] = txs.slice(1).map(tx => ({ tx, error: new Error('Invalid tx') }));
+      checkpointBuilder.buildBlock.mockResolvedValue({ failedTxs, numTxs: 1 } as BuildBlockInCheckpointResult);
+
+      const checkpoint = await job.buildSingleBlock(checkpointBuilder, {
+        blockNumber: newBlockNumber,
+        indexWithinCheckpoint: IndexWithinCheckpoint(1),
+        buildDeadline: undefined,
+        blockTimestamp: 0n,
+        remainingBlobFields: 1,
+        txHashesAlreadyIncluded: new Set<string>(),
+      });
+
+      expect(checkpoint).toBeUndefined();
+      expect(p2p.deleteTxs).toHaveBeenCalledWith(failedTxs.map(ftx => ftx.tx.txHash));
+    });
+
+    it('does not build a block if checkpoint builder fails with invalid txs', async () => {
+      job.updateConfig({ minTxsPerBlock: 3 });
+      const txs = await timesAsync(3, i => makeTx(i + 1, chainId));
+      mockPendingTxs(p2p, txs);
+
+      const checkpointBuilder = mock<CheckpointBuilder>();
+      const failedTxs: FailedTx[] = txs.slice(1).map(tx => ({ tx, error: new Error('Invalid tx') }));
+      checkpointBuilder.buildBlock.mockRejectedValue(new NoValidTxsError(failedTxs));
+
+      const checkpoint = await job.buildSingleBlock(checkpointBuilder, {
+        blockNumber: newBlockNumber,
+        indexWithinCheckpoint: IndexWithinCheckpoint(1),
+        buildDeadline: undefined,
+        blockTimestamp: 0n,
+        remainingBlobFields: 1,
+        txHashesAlreadyIncluded: new Set<string>(),
+      });
+
+      expect(checkpoint).toBeUndefined();
+      expect(p2p.deleteTxs).toHaveBeenCalledWith(failedTxs.map(ftx => ftx.tx.txHash));
+    });
+  });
+
   describe('timing edge cases', () => {
     it('handles insufficient time remaining in slot', async () => {
       // Mock canStartNextBlock to return false (not enough time)
@@ -855,7 +990,7 @@ describe('CheckpointProposalJob', () => {
     });
   });
 
-  describe('HA error handling during block building', () => {
+  describe('high-availability error handling during block building', () => {
     it('should stop checkpoint building when block proposal throws DutyAlreadySignedError on first block', async () => {
       // Set up test data for 3 blocks (to verify it stops even with multiple blocks configured)
       const { lastBlock } = await setupMultipleBlocks(3, 1);
@@ -961,4 +1096,20 @@ class TestCheckpointProposalJob extends CheckpointProposalJob {
   public getTimetable(): SequencerTimetable {
     return this.timetable;
   }
+
+  /** Expose internal buildSingleBlock method */
+  public override buildSingleBlock(
+    checkpointBuilder: CheckpointBuilder,
+    opts: {
+      forceCreate?: boolean;
+      blockTimestamp: bigint;
+      blockNumber: BlockNumber;
+      indexWithinCheckpoint: IndexWithinCheckpoint;
+      buildDeadline: Date | undefined;
+      txHashesAlreadyIncluded: Set<string>;
+      remainingBlobFields: number;
+    },
+  ): Promise<{ block: L2Block; usedTxs: Tx[]; remainingBlobFields: number } | { error: Error } | undefined> {
+    return super.buildSingleBlock(checkpointBuilder, opts);
+  }
 }