@aztec-labs/sequencer-client 6.0.0-nightly.20260829

package/src/sequencer/types.ts

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

package/src/sequencer/utils.ts

@@ -0,0 +1,42 @@
+export enum SequencerState {
+  /** Sequencer is stopped and not processing any txs from the pool. */
+  STOPPED = 'STOPPED',
+  /** Sequencer is being stopped. Will move to STOPPED shortly. */
+  STOPPING = 'STOPPING',
+  /** Sequencer is awaiting the next call to work(). */
+  IDLE = 'IDLE',
+  /** Synchronizing with the L2 chain. */
+  SYNCHRONIZING = 'SYNCHRONIZING',
+  /** Checking if we are the proposer for the current slot. */
+  PROPOSER_CHECK = 'PROPOSER_CHECK',
+  /** Initializing the checkpoint proposal. */
+  INITIALIZING_CHECKPOINT = 'INITIALIZING_CHECKPOINT',
+  /** Waiting for transactions to arrive in the pool. */
+  WAITING_FOR_TXS = 'WAITING_FOR_TXS',
+  /** Creating a new L2 block. Includes processing public function calls. */
+  CREATING_BLOCK = 'CREATING_BLOCK',
+  /** Waiting until the next block can be created. */
+  WAITING_UNTIL_NEXT_BLOCK = 'WAITING_UNTIL_NEXT_BLOCK',
+  /** Assembling and broadcasting the checkpoint. */
+  ASSEMBLING_CHECKPOINT = 'ASSEMBLING_CHECKPOINT',
+  /** Collecting attestations from its peers. */
+  COLLECTING_ATTESTATIONS = 'COLLECTING_ATTESTATIONS',
+  /** Sending the tx to L1 with the L2 checkpoint data and awaiting it to be mined.. */
+  PUBLISHING_CHECKPOINT = 'PUBLISHING_CHECKPOINT',
+}
+
+export type SequencerStateWithSlot =
+  | SequencerState.INITIALIZING_CHECKPOINT
+  | SequencerState.WAITING_FOR_TXS
+  | SequencerState.CREATING_BLOCK
+  | SequencerState.WAITING_UNTIL_NEXT_BLOCK
+  | SequencerState.COLLECTING_ATTESTATIONS
+  | SequencerState.PUBLISHING_CHECKPOINT
+  | SequencerState.PROPOSER_CHECK
+  | SequencerState.ASSEMBLING_CHECKPOINT;
+
+export type SequencerStateCallback = () => SequencerState;
+
+export function sequencerStateToNumber(state: SequencerState): number {
+  return Object.values(SequencerState).indexOf(state);
+}

package/src/test/index.ts

@@ -0,0 +1,26 @@
+import type { L1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
+import type { PublisherManager } from '@aztec-labs/ethereum/publisher-manager';
+import type { PublicProcessorFactory } from '@aztec-labs/simulator/server';
+import type { ProposerTimetable } from '@aztec-labs/stdlib/timetable';
+import type { FullNodeCheckpointsBuilder, ValidatorClient } from '@aztec-labs/validator-client';
+
+import { SequencerClient } from '../client/sequencer-client.js';
+import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
+import { Sequencer } from '../sequencer/sequencer.js';
+
+class TestSequencer_ extends Sequencer {
+  declare public publicProcessorFactory: PublicProcessorFactory;
+  declare public timetable: ProposerTimetable;
+  declare public publisherFactory: SequencerPublisherFactory;
+  declare public validatorClient: ValidatorClient;
+  declare public checkpointsBuilder: FullNodeCheckpointsBuilder;
+}
+
+export type TestSequencer = TestSequencer_;
+
+class TestSequencerClient_ extends SequencerClient {
+  declare public sequencer: TestSequencer;
+  declare public publisherManager: PublisherManager<L1TxUtils>;
+}
+
+export type TestSequencerClient = TestSequencerClient_;

package/src/test/mock_checkpoint_builder.ts

@@ -0,0 +1,324 @@
+import { type BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec-labs/foundation/log';
+import { unfreeze } from '@aztec-labs/foundation/types';
+import { L2Block } from '@aztec-labs/stdlib/block';
+import { Checkpoint } from '@aztec-labs/stdlib/checkpoint';
+import type {
+  BlockBuilderOptions,
+  FullNodeBlockBuilderConfig,
+  ICheckpointBlockBuilder,
+  ICheckpointsBuilder,
+  MerkleTreeWriteOperations,
+} from '@aztec-labs/stdlib/interfaces/server';
+import { CheckpointHeader } from '@aztec-labs/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot } from '@aztec-labs/stdlib/testing';
+import type { CheckpointGlobalVariables, Tx } from '@aztec-labs/stdlib/tx';
+import type { BuildBlockInCheckpointResult } from '@aztec-labs/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: L2Block[] = [];
+  private builtBlocks: L2Block[] = [];
+  private usedTxsPerBlock: Tx[][] = [];
+  private blockIndex = 0;
+
+  /** Optional function to dynamically provide the block (alternative to seedBlocks) */
+  private blockProvider: (() => L2Block) | undefined = undefined;
+
+  /** Track calls for assertions */
+  public buildBlockCalls: Array<{
+    blockNumber: BlockNumber;
+    timestamp: bigint;
+    opts: BlockBuilderOptions;
+  }> = [];
+  /** Track all consumed transaction hashes across buildBlock calls */
+  public consumedTxHashes: Set<string> = new Set();
+  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: L2Block[], 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: () => L2Block): this {
+    this.blockProvider = provider;
+    this.blocks = [];
+    return this;
+  }
+
+  getConstantData(): CheckpointGlobalVariables {
+    return this.constants;
+  }
+
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: BlockBuilderOptions,
+  ): Promise<BuildBlockInCheckpointResult> {
+    this.buildBlockCalls.push({ blockNumber, timestamp, opts });
+
+    if (this.errorOnBuild) {
+      throw this.errorOnBuild;
+    }
+
+    let block: L2Block;
+    let usedTxs: Tx[];
+
+    if (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 {
+      // Seeded mode: get block from pre-seeded list
+      block = this.blocks[this.blockIndex];
+      usedTxs = this.usedTxsPerBlock[this.blockIndex] ?? [];
+      this.blockIndex++;
+      this.builtBlocks.push(block);
+    }
+
+    // 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,
+      publicProcessorDuration: 0,
+      numTxs: block?.body?.txEffects?.length ?? usedTxs.length,
+      usedTxs,
+      failedTxs: [],
+    };
+  }
+
+  completeCheckpoint(): Promise<Checkpoint> {
+    this.completeCheckpointCalled = true;
+    const allBlocks = this.blockProvider ? this.builtBlocks : this.blocks;
+    return this.buildCheckpoint(allBlocks);
+  }
+
+  getCheckpoint(): Promise<Checkpoint> {
+    this.getCheckpointCalled = true;
+    const builtBlocks = this.blockProvider ? this.builtBlocks : this.blocks.slice(0, this.blockIndex);
+    if (builtBlocks.length === 0) {
+      throw new Error('No blocks built yet');
+    }
+    return this.buildCheckpoint(builtBlocks);
+  }
+
+  /** 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: lastBlock.header.totalManaUsed,
+    });
+
+    return new Checkpoint(
+      makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
+      checkpointHeader,
+      blocks,
+      this.checkpointNumber,
+    );
+  }
+
+  /** Resets per-checkpoint state (built blocks, consumed txs) while preserving config (blockProvider, seeded blocks). */
+  resetCheckpointState(): void {
+    this.builtBlocks = [];
+    this.blockIndex = 0;
+    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();
+  }
+}
+
+/**
+ * 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 ICheckpointsBuilder {
+  private checkpointBuilder: MockCheckpointBuilder | undefined;
+
+  /** Track calls for assertions */
+  public startCheckpointCalls: Array<{
+    checkpointNumber: CheckpointNumber;
+    constants: CheckpointGlobalVariables;
+    previousCheckpointOutHashes: Fr[];
+    feeAssetPriceModifier: bigint;
+  }> = [];
+  public openCheckpointCalls: Array<{
+    checkpointNumber: CheckpointNumber;
+    constants: CheckpointGlobalVariables;
+    l1ToL2Messages: Fr[];
+    previousCheckpointOutHashes: Fr[];
+    existingBlocks: L2Block[];
+    feeAssetPriceModifier: bigint;
+  }> = [];
+  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;
+  }
+
+  getConfig(): FullNodeBlockBuilderConfig {
+    return {
+      l1GenesisTime: 0n,
+      slotDuration: 24,
+      l1ChainId: 1,
+      rollupVersion: 1,
+      rollupManaLimit: 200_000_000,
+    };
+  }
+
+  updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void {
+    this.updateConfigCalls.push(config);
+  }
+
+  startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
+    previousCheckpointOutHashes: Fr[],
+    _previousInboxRollingHash: Fr,
+    _fork: MerkleTreeWriteOperations,
+    _bindings?: LoggerBindings,
+  ): Promise<ICheckpointBlockBuilder> {
+    this.startCheckpointCalls.push({
+      checkpointNumber,
+      constants,
+      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);
+  }
+
+  openCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    _previousInboxRollingHash: Fr,
+    _fork: MerkleTreeWriteOperations,
+    existingBlocks: L2Block[] = [],
+  ): Promise<ICheckpointBlockBuilder> {
+    this.openCheckpointCalls.push({
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      existingBlocks,
+      feeAssetPriceModifier,
+    });
+
+    if (!this.checkpointBuilder) {
+      // Auto-create a builder if none was set
+      this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    }
+
+    return Promise.resolve(this.checkpointBuilder);
+  }
+
+  getFork(_blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations> {
+    throw new Error('MockCheckpointsBuilder.getFork not implemented');
+  }
+
+  /** Reset for reuse in another test */
+  reset(): void {
+    this.checkpointBuilder = undefined;
+    this.startCheckpointCalls = [];
+    this.openCheckpointCalls = [];
+    this.updateConfigCalls = [];
+  }
+}

package/src/test/utils.ts

@@ -0,0 +1,215 @@
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec-labs/foundation/branded-types';
+import { times } from '@aztec-labs/foundation/collection';
+import { Secp256k1Signer } from '@aztec-labs/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { Signature } from '@aztec-labs/foundation/eth-signature';
+import type { P2P } from '@aztec-labs/p2p';
+import { PublicDataWrite } from '@aztec-labs/stdlib/avm';
+import { Body, CommitteeAttestation, L2Block } from '@aztec-labs/stdlib/block';
+import { DEFAULT_BLOCK_DURATION_MS } from '@aztec-labs/stdlib/config';
+import type { L1RollupConstants } from '@aztec-labs/stdlib/epoch-helpers';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal, ConsensusPayload } from '@aztec-labs/stdlib/p2p';
+import { CheckpointHeader } from '@aztec-labs/stdlib/rollup';
+import {
+  TEST_COORDINATION_SIGNATURE_CONTEXT,
+  makeAppendOnlyTreeSnapshot,
+  mockTxForRollup,
+} from '@aztec-labs/stdlib/testing';
+import {
+  DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+  DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+  DEFAULT_MIN_BLOCK_DURATION,
+  DEFAULT_P2P_PROPAGATION_TIME,
+  ProposerTimetable,
+} from '@aztec-labs/stdlib/timetable';
+import { BlockHeader, GlobalVariables, type Tx, makeProcessedTxFromPrivateOnlyTx } from '@aztec-labs/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';
+
+/**
+ * Builds a {@link ProposerTimetable} for tests from a millisecond block duration and optional budgets,
+ * filling unset budgets with the shared `DEFAULT_*` values the sequencer config layer applies. Mirrors how
+ * the sequencer constructs its timetable so tests exercise the same budget resolution.
+ */
+export function makeProposerTimetable(opts: {
+  l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>;
+  blockDurationMs?: number;
+  minBlockDuration?: number;
+  p2pPropagationTime?: number;
+  checkpointProposalPrepareTime?: number;
+}): ProposerTimetable {
+  return new ProposerTimetable({
+    l1Constants: opts.l1Constants,
+    blockDuration: (opts.blockDurationMs ?? DEFAULT_BLOCK_DURATION_MS) / 1000,
+    minBlockDuration: opts.minBlockDuration ?? DEFAULT_MIN_BLOCK_DURATION,
+    p2pPropagationTime: opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME,
+    checkpointProposalPrepareTime: opts.checkpointProposalPrepareTime ?? DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+    checkpointProposalInitTime: DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+  });
+}
+
+/**
+ * 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 L2Block from transactions and global variables
+ */
+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),
+    ),
+  );
+  const body = new Body(processedTxs.map(tx => tx.txEffect));
+  const header = BlockHeader.empty({ globalVariables });
+  const archive = makeAppendOnlyTreeSnapshot(globalVariables.blockNumber + 1);
+  return new L2Block(
+    archive,
+    header,
+    body,
+    CheckpointNumber.fromBlockNumber(globalVariables.blockNumber),
+    IndexWithinCheckpoint(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.hasEligiblePendingTxs.mockImplementation(minCount => Promise.resolve(txs.length >= minCount));
+  p2p.iteratePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
+  p2p.iterateEligiblePendingTxs.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 L2Block for testing purposes.
+ * Uses mock values for blockHeadersHash and blobsHash since L2Block doesn't have these fields.
+ */
+function createCheckpointHeaderFromBlock(block: L2Block): CheckpointHeader {
+  const gv = block.header.globalVariables;
+  return new CheckpointHeader(
+    block.header.lastArchive.root,
+    Fr.random(), // blockHeadersHash - mock value for testing
+    Fr.random(), // blobsHash - mock value for testing
+    Fr.random(), // inboxRollingHash - mock value for testing
+    Fr.random(), // outHash - mock value for testing
+    gv.slotNumber,
+    gv.timestamp,
+    gv.coinbase,
+    gv.feeRecipient,
+    gv.gasFees,
+    block.header.totalManaUsed,
+    block.header.totalFees,
+  );
+}
+
+/**
+ * Creates a block proposal from a block and signature
+ */
+export function createBlockProposal(block: L2Block, signature: Signature): BlockProposal {
+  const txHashes = block.body.txEffects.map(tx => tx.txHash);
+  return new BlockProposal(
+    block.header,
+    block.indexWithinCheckpoint,
+    block.archive.root,
+    txHashes,
+    signature,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
+  );
+}
+
+/**
+ * Creates a checkpoint proposal from a block and signature
+ */
+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,
+    feeAssetPriceModifier,
+    checkpointSignature,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
+    {
+      blockHeader: block.header,
+      indexWithinCheckpoint: block.indexWithinCheckpoint,
+      txHashes,
+      signature: blockSignature ?? checkpointSignature, // Use checkpoint signature as block signature if not provided
+    },
+  );
+}
+
+/**
+ * Creates a checkpoint 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 createCheckpointAttestation(
+  block: L2Block,
+  signature: Signature,
+  sender: EthAddress,
+  feeAssetPriceModifier: bigint = 0n,
+): CheckpointAttestation {
+  const checkpointHeader = createCheckpointHeaderFromBlock(block);
+  const payload = new ConsensusPayload(
+    checkpointHeader,
+    block.archive.root,
+    feeAssetPriceModifier,
+    TEST_COORDINATION_SIGNATURE_CONTEXT,
+  );
+  const attestation = new CheckpointAttestation(payload, signature, signature);
+  // Bypass signature recovery for testing since we use random signatures
+  (attestation as any).getSender = () => sender;
+  (attestation as any).getProposer = () => 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: L2Block }> {
+  const txs = await Promise.all(times(txCount, i => makeTx(i + 1, chainId)));
+  const block = await makeBlock(txs, globalVariables);
+  mockPendingTxs(p2p, txs);
+  return { txs, block };
+}