@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/block/l2_block_source.ts

@@ -1,17 +1,27 @@
+import {
+  BlockNumber,
+  BlockNumberSchema,
+  CheckpointNumber,
+  type EpochNumber,
+  type SlotNumber,
+} from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import type { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
-import { BlockAttestation } from '../p2p/block_attestation.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
+import { type CheckpointedL2Block, PublishedL2Block } from './checkpointed_l2_block.js';
 import type { L2Block } from './l2_block.js';
-import { PublishedL2Block } from './published_l2_block.js';
+import type { L2BlockNew } from './l2_block_new.js';
+import type { ValidateBlockNegativeResult, ValidateBlockResult } from './validate_block_result.js';
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -33,39 +43,63 @@ export interface L2BlockSource {
    * Gets the number of the latest L2 block processed by the block source implementation.
    * @returns The number of the latest L2 block processed by the block source implementation.
    */
-  getBlockNumber(): Promise<number>;
+  getBlockNumber(): Promise<BlockNumber>;
 
   /**
    * Gets the number of the latest L2 block proven seen by the block source implementation.
    * @returns The number of the latest L2 block proven seen by the block source implementation.
    */
-  getProvenBlockNumber(): Promise<number>;
-
-  /**
-   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
-   */
-  getBlock(number: number): Promise<L2Block | undefined>;
+  getProvenBlockNumber(): Promise<BlockNumber>;
 
   /**
    * Gets an l2 block header.
    * @param number - The block number to return or 'latest' for the most recent one.
    * @returns The requested L2 block header.
    */
-  getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined>;
+  getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined>;
 
   /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The maximum number of blocks to return.
-   * @param proven - If true, only return blocks that have been proven.
-   * @returns The requested L2 blocks.
+   * Gets a checkpointed L2 block by block number.
+   * Returns undefined if the block doesn't exist or hasn't been checkpointed yet.
+   * @param number - The block number to retrieve.
+   * @returns The requested checkpointed L2 block (or undefined if not found or not checkpointed).
    */
-  getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
+  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
-  /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+  /**
+   * Retrieves a collection of published checkpoints
+   * @param checkpointNumber The first checkpoint to be retrieved
+   * @param limit The number of checkpoints to be retrieved
+   * @returns The collection of complete checkpoints
+   */
+  getPublishedCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+
+  /**
+   * Gets the checkpoints for a given epoch
+   * @param epochNumber - Epoch for which we want checkpoint data
+   */
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
+
+  /**
+   * Gets a block header by its hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested block header (or undefined if not found).
+   */
+  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined>;
+
+  /**
+   * Gets a block header by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested block header (or undefined if not found).
+   */
+  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
+
+  /**
+   * Gets an L2 block by block number.
+   * @param number - The block number to return.
+   * @returns The requested L2 block (or undefined if not found).
+   */
+  getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined>;
 
   /**
    * Gets a tx effect.
@@ -82,34 +116,27 @@ export interface L2BlockSource {
   getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
 
   /**
-   * Returns the current L2 slot number based on the current L1 timestamp.
+   * Returns the current L2 slot number based on the currently synced L1 timestamp.
    */
-  getL2SlotNumber(): Promise<bigint>;
+  getL2SlotNumber(): Promise<SlotNumber | undefined>;
 
   /**
-   * Returns the current L2 epoch number based on the current L1 timestamp.
+   * Returns the current L2 epoch number based on the currently synced L1 timestamp.
    */
-  getL2EpochNumber(): Promise<bigint>;
-
-  /**
-   * Returns all blocks for a given epoch.
-   * @dev Use this method only with recent epochs, since it walks the block list backwards.
-   * @param epochNumber - The epoch number to return blocks for.
-   */
-  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]>;
+  getL2EpochNumber(): Promise<EpochNumber | undefined>;
 
   /**
    * Returns all block headers for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
    * @param epochNumber - The epoch number to return headers for.
    */
-  getBlockHeadersForEpoch(epochNumber: bigint): Promise<BlockHeader[]>;
+  getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
 
   /**
    * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
    * @param epochNumber - The epoch number to check.
    */
-  isEpochComplete(epochNumber: bigint): Promise<boolean>;
+  isEpochComplete(epochNumber: EpochNumber): Promise<boolean>;
 
   /**
    * Returns the tips of the L2 chain.
@@ -121,8 +148,11 @@ export interface L2BlockSource {
    */
   getL1Constants(): Promise<L1RollupConstants>;
 
+  /** Returns values for the genesis block */
+  getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }>;
+
   /** Latest synced L1 timestamp. */
-  getL1Timestamp(): Promise<bigint>;
+  getL1Timestamp(): Promise<bigint | undefined>;
 
   /**
    * Returns whether the latest block in the pending chain on L1 is invalid (ie its attestations are incorrect).
@@ -138,61 +168,67 @@ export interface L2BlockSource {
 
   /** Force a sync. */
   syncImmediate(): Promise<void>;
+
+  /* Legacy APIS */
+
+  /**
+   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   * @deprecated Use getL2BlockNew instead.
+   */
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
+
+  /**
+   * Returns all blocks for a given epoch.
+   * @dev Use this method only with recent epochs, since it walks the block list backwards.
+   * @param epochNumber - The epoch number to return blocks for.
+   */
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
+
+  /**
+   * Gets a published block by its block hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested block (or undefined if not found).
+   */
+  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets a published block by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested block (or undefined if not found).
+   */
+  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The maximum number of blocks to return.
+   * @param proven - If true, only return blocks that have been proven.
+   * @returns The requested L2 blocks.
+   */
+  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
+
+  /** Equivalent to getBlocks but includes publish data. */
+  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
 }
 
-/** Subtype for invalid block validation results */
-export type ValidateBlockNegativeResult =
-  | {
-      valid: false;
-      block: PublishedL2Block;
-      committee: EthAddress[];
-      epoch: bigint;
-      seed: bigint;
-      attestations: BlockAttestation[];
-      reason: 'insufficient-attestations';
-    }
-  | {
-      valid: false;
-      block: PublishedL2Block;
-      committee: EthAddress[];
-      epoch: bigint;
-      seed: bigint;
-      reason: 'invalid-attestation';
-      attestations: BlockAttestation[];
-      invalidIndex: number;
-    };
-
-/** Result type for validating a block attestations */
-export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
-
-export const ValidateBlockResultSchema = z.union([
-  z.object({ valid: z.literal(true), block: PublishedL2Block.schema.optional() }),
-  z.object({
-    valid: z.literal(false),
-    block: PublishedL2Block.schema,
-    committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
-    seed: schemas.BigInt,
-    attestations: z.array(BlockAttestation.schema),
-    reason: z.literal('insufficient-attestations'),
-  }),
-  z.object({
-    valid: z.literal(false),
-    block: PublishedL2Block.schema,
-    committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
-    seed: schemas.BigInt,
-    attestations: z.array(BlockAttestation.schema),
-    reason: z.literal('invalid-attestation'),
-    invalidIndex: z.number(),
-  }),
-]) satisfies ZodFor<ValidateBlockResult>;
+/**
+ * Interface for classes that can receive and store L2 blocks.
+ */
+export interface L2BlockSink {
+  /**
+   * Adds a block to the store.
+   * @param block - The L2 block to add.
+   * @throws If block number is not incremental (i.e., not exactly one more than the last stored block).
+   */
+  addBlock(block: L2BlockNew): Promise<void>;
+}
 
 /**
  * L2BlockSource that emits events upon pending / proven chain changes.
  * see L2BlockSourceEvents for the events emitted.
  */
-
 export type ArchiverEmitter = TypedEventEmitter<{
   [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockPruneEvent) => void;
   [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockProvenEvent) => void;
@@ -212,33 +248,26 @@ export type L2BlockTag = 'latest' | 'proven' | 'finalized';
 export type L2Tips = Record<L2BlockTag, L2BlockId>;
 
 /** Identifies a block by number and hash. */
-export type L2BlockId = z.infer<typeof L2BlockIdSchema>;
+export type L2BlockId = { number: BlockNumber; hash: string };
 
 /** Creates an L2 block id */
-export function makeL2BlockId(number: number, hash?: string): L2BlockId {
+export function makeL2BlockId(number: BlockNumber, hash?: string): L2BlockId {
   if (number !== 0 && !hash) {
     throw new Error(`Hash is required for non-genesis blocks (got block number ${number})`);
   }
   return { number, hash: hash! };
 }
 
-// TODO(palla/schemas): This package should know what is the block hash of the genesis block 0.
-const L2BlockIdSchema = z.union([
-  z.object({
-    number: z.literal(0),
-    hash: z.undefined(),
-  }),
-  z.object({
-    number: z.number(),
-    hash: z.string(),
-  }),
-]);
+const L2BlockIdSchema = z.object({
+  number: BlockNumberSchema,
+  hash: z.string(),
+});
 
 export const L2TipsSchema = z.object({
   latest: L2BlockIdSchema,
   proven: L2BlockIdSchema,
   finalized: L2BlockIdSchema,
-}) satisfies z.ZodType<L2Tips>;
+});
 
 export enum L2BlockSourceEvents {
   L2PruneDetected = 'l2PruneDetected',
@@ -248,14 +277,14 @@ export enum L2BlockSourceEvents {
 
 export type L2BlockProvenEvent = {
   type: 'l2BlockProven';
-  blockNumber: bigint;
-  slotNumber: bigint;
-  epochNumber: bigint;
+  blockNumber: BlockNumber;
+  slotNumber: SlotNumber;
+  epochNumber: EpochNumber;
 };
 
 export type L2BlockPruneEvent = {
   type: 'l2PruneDetected';
-  epochNumber: bigint;
+  epochNumber: EpochNumber;
   blocks: L2Block[];
 };
 

package/src/block/l2_block_stream/interfaces.ts

@@ -1,5 +1,5 @@
+import type { PublishedL2Block } from '../checkpointed_l2_block.js';
 import type { L2BlockId, L2Tips } from '../l2_block_source.js';
-import type { PublishedL2Block } from '../published_l2_block.js';
 
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
 export interface L2BlockStreamLocalDataProvider {

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -25,6 +26,10 @@ export class L2BlockStream {
       skipFinalized?: boolean;
     } = {},
   ) {
+    // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
+    // which makes it run periodically, or `sync`, which triggers it once.
+    // Users of L2BlockStream decide what mode to run it in (_periodically_ vs _manually triggered_).
+    // The default is _manually triggered_.
     this.runningPromise = new RunningPromise(() => this.work(), log, this.opts.pollIntervalMS ?? 1000);
   }
 
@@ -41,6 +46,11 @@ export class L2BlockStream {
     return this.runningPromise.isRunning();
   }
 
+  /**
+   * Runs the synchronization process once.
+   *
+   * If you want to run this process continuously use `start` and `stop` instead.
+   */
   public async sync() {
     this.isSyncing = true;
     await this.runningPromise.trigger();
@@ -74,7 +84,7 @@ export class L2BlockStream {
       }
 
       if (latestBlockNumber < localTips.latest.number) {
-        latestBlockNumber = Math.min(latestBlockNumber, sourceTips.latest.number); // see #13471
+        latestBlockNumber = BlockNumber(Math.min(latestBlockNumber, sourceTips.latest.number)); // see #13471
         const hash = sourceCache.get(latestBlockNumber) ?? (await this.getBlockHashFromSource(latestBlockNumber));
         if (latestBlockNumber !== 0 && !hash) {
           throw new Error(`Block hash not found in block source for block number ${latestBlockNumber}`);
@@ -85,7 +95,7 @@ export class L2BlockStream {
 
       // If we are just starting, use the starting block number from the options.
       if (latestBlockNumber === 0 && this.opts.startingBlock !== undefined) {
-        latestBlockNumber = Math.max(this.opts.startingBlock - 1, 0);
+        latestBlockNumber = BlockNumber(Math.max(this.opts.startingBlock - 1, 0));
       }
 
       // Only log this entry once (for sanity)
@@ -108,7 +118,11 @@ export class L2BlockStream {
       while (nextBlockNumber <= sourceTips.latest.number) {
         const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.latest.number - nextBlockNumber + 1);
         this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getPublishedBlocks(nextBlockNumber, limit, this.opts.proven);
+        const blocks = await this.l2BlockSource.getPublishedBlocks(
+          BlockNumber(nextBlockNumber),
+          limit,
+          this.opts.proven,
+        );
         if (blocks.length === 0) {
           break;
         }
@@ -139,7 +153,7 @@ export class L2BlockStream {
    * @param blockNumber - The block number to test.
    * @param args - A cache of data already requested from source, to avoid re-requesting it.
    */
-  private async areBlockHashesEqualAt(blockNumber: number, args: { sourceCache: BlockHashCache }) {
+  private async areBlockHashesEqualAt(blockNumber: BlockNumber, args: { sourceCache: BlockHashCache }) {
     if (blockNumber === 0) {
       return true;
     }
@@ -163,7 +177,7 @@ export class L2BlockStream {
     return localBlockHash === sourceBlockHash;
   }
 
-  private getBlockHashFromSource(blockNumber: number) {
+  private getBlockHashFromSource(blockNumber: BlockNumber) {
     return this.l2BlockSource
       .getBlockHeader(blockNumber)
       .then(h => h?.hash())

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -1,3 +1,6 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+
 import type { L2Block } from '../l2_block.js';
 import type { L2BlockId, L2BlockTag, L2Tips } from '../l2_block_source.js';
 import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
@@ -7,7 +10,7 @@ import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalD
  * @dev tests in kv-store/src/stores/l2_tips_memory_store.test.ts
  */
 export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider {
-  protected readonly l2TipsStore: Map<L2BlockTag, number> = new Map();
+  protected readonly l2TipsStore: Map<L2BlockTag, BlockNumber> = new Map();
   protected readonly l2BlockHashesStore: Map<number, string> = new Map();
 
   public getL2BlockHash(number: number): Promise<string | undefined> {
@@ -25,7 +28,7 @@ export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStre
   private getL2Tip(tag: L2BlockTag): L2BlockId {
     const blockNumber = this.l2TipsStore.get(tag);
     if (blockNumber === undefined || blockNumber === 0) {
-      return { number: 0, hash: undefined };
+      return { number: BlockNumber.ZERO, hash: GENESIS_BLOCK_HEADER_HASH.toString() };
     }
     const blockHash = this.l2BlockHashesStore.get(blockNumber);
     if (!blockHash) {
@@ -70,6 +73,6 @@ export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStre
   }
 
   protected computeBlockHash(block: L2Block) {
-    return block.header.hash().then(hash => hash.toString());
+    return block.hash().then(hash => hash.toString());
   }
 }

package/src/block/proposal/attestations_and_signers.ts

@@ -0,0 +1,140 @@
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
+import { hexToBuffer } from '@aztec/foundation/string';
+
+import { encodeAbiParameters, parseAbiParameters } from 'viem';
+import { z } from 'zod';
+
+import type { Signable, SignatureDomainSeparator } from '../../p2p/signature_utils.js';
+import { CommitteeAttestation, EthAddress } from './committee_attestation.js';
+
+export class CommitteeAttestationsAndSigners implements Signable {
+  constructor(public attestations: CommitteeAttestation[]) {}
+
+  static get schema() {
+    return z
+      .object({
+        attestations: CommitteeAttestation.schema.array(),
+      })
+      .transform(obj => new CommitteeAttestationsAndSigners(obj.attestations));
+  }
+
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    const abi = parseAbiParameters('uint8,(bytes,bytes),address[]');
+    const packed = this.getPackedAttestations();
+
+    const encodedData = encodeAbiParameters(abi, [
+      domainSeparator,
+      [packed.signatureIndices, packed.signaturesOrAddresses],
+      this.getSigners().map(s => s.toString()),
+    ]);
+
+    return hexToBuffer(encodedData);
+  }
+
+  static empty(): CommitteeAttestationsAndSigners {
+    return new CommitteeAttestationsAndSigners([]);
+  }
+
+  toString() {
+    throw new Error('Not implemented');
+  }
+
+  getSigners() {
+    return this.attestations.filter(a => !a.signature.isEmpty()).map(a => a.address);
+  }
+
+  getSignedAttestations() {
+    return this.attestations.filter(a => !a.signature.isEmpty());
+  }
+
+  /**
+   * Packs an array of committee attestations into the format expected by the Solidity contract
+   *
+   * @param attestations - Array of committee attestations with addresses and signatures
+   * @returns Packed attestations with bitmap and tightly packed signature/address data
+   */
+  getPackedAttestations(): ViemCommitteeAttestations {
+    const length = this.attestations.length;
+    const attestations = this.attestations.map(a => a.toViem());
+
+    // Calculate bitmap size (1 bit per attestation, rounded up to nearest byte)
+    const bitmapSize = Math.ceil(length / 8);
+    const signatureIndices = new Uint8Array(bitmapSize);
+
+    // Calculate total data size needed
+    let totalDataSize = 0;
+    for (let i = 0; i < length; i++) {
+      const signature = attestations[i].signature;
+      // Check if signature is empty (v = 0)
+      const isEmpty = signature.v === 0;
+
+      if (!isEmpty) {
+        totalDataSize += 65; // v (1) + r (32) + s (32)
+      } else {
+        totalDataSize += 20; // address only
+      }
+    }
+
+    const signaturesOrAddresses = new Uint8Array(totalDataSize);
+    let dataIndex = 0;
+
+    // Pack the data
+    for (let i = 0; i < length; i++) {
+      const attestation = attestations[i];
+      const signature = attestation.signature;
+
+      // Check if signature is empty
+      const isEmpty = signature.v === 0;
+
+      if (!isEmpty) {
+        // Set bit in bitmap (bit 7-0 in each byte, left to right)
+        const byteIndex = Math.floor(i / 8);
+        const bitIndex = 7 - (i % 8);
+        signatureIndices[byteIndex] |= 1 << bitIndex;
+
+        // Pack signature: v + r + s
+        signaturesOrAddresses[dataIndex] = signature.v;
+        dataIndex++;
+
+        // Pack r (32 bytes)
+        const rBytes = Buffer.from(signature.r.slice(2), 'hex');
+        signaturesOrAddresses.set(rBytes, dataIndex);
+        dataIndex += 32;
+
+        // Pack s (32 bytes)
+        const sBytes = Buffer.from(signature.s.slice(2), 'hex');
+        signaturesOrAddresses.set(sBytes, dataIndex);
+        dataIndex += 32;
+      } else {
+        // Pack address only (20 bytes)
+        const addrBytes = Buffer.from(attestation.addr.slice(2), 'hex');
+        signaturesOrAddresses.set(addrBytes, dataIndex);
+        dataIndex += 20;
+      }
+    }
+
+    return {
+      signatureIndices: `0x${Buffer.from(signatureIndices).toString('hex')}`,
+      signaturesOrAddresses: `0x${Buffer.from(signaturesOrAddresses).toString('hex')}`,
+    };
+  }
+}
+
+/**
+ * Malicious extension of CommitteeAttestationsAndSigners that keeps separate attestations and
+ * signers. Used for tricking the L1 contract into accepting attestations by reconstructing
+ * the correct committee commitment (which relies on the signers, ignoring the signatures)
+ * with an invalid set of attestation signatures.
+ */
+export class MaliciousCommitteeAttestationsAndSigners extends CommitteeAttestationsAndSigners {
+  constructor(
+    attestations: CommitteeAttestation[],
+    private signers: EthAddress[],
+  ) {
+    super(attestations);
+  }
+
+  override getSigners(): EthAddress[] {
+    return this.signers;
+  }
+}

package/src/block/proposal/committee_attestation.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';

package/src/block/proposal/index.ts

@@ -1 +1,2 @@
 export * from './committee_attestation.js';
+export * from './attestations_and_signers.js';

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,7 +1,9 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import type { L2Block, L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
-import type { BlockHeader } from '@aztec/stdlib/tx';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
+import { L1PublishedData } from '@aztec/stdlib/checkpoint';
 
 import { jestExpect as expect } from '@jest/expect';
 
@@ -14,18 +16,22 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     tipsStore = await makeTipsStore();
   });
 
-  const makeBlock = (number: number): PublishedL2Block => ({
-    block: { number, header: { hash: () => Promise.resolve(new Fr(number)) } as BlockHeader } as L2Block,
-    l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
-    attestations: [],
-  });
+  const makeBlock = (number: number): PublishedL2Block =>
+    PublishedL2Block.fromFields({
+      block: { number: BlockNumber(number), hash: () => Promise.resolve(new Fr(number)) } as L2Block,
+      l1: new L1PublishedData(BigInt(number), BigInt(number), `0x${number}`),
+      attestations: [],
+    });
 
   const makeBlockId = (number: number): L2BlockId => ({
-    number,
+    number: BlockNumber(number),
     hash: new Fr(number).toString(),
   });
 
-  const makeTip = (number: number) => ({ number, hash: number === 0 ? undefined : new Fr(number).toString() });
+  const makeTip = (number: number): L2BlockId => ({
+    number: BlockNumber(number),
+    hash: number === 0 ? GENESIS_BLOCK_HEADER_HASH.toString() : new Fr(number).toString(),
+  });
 
   const makeTips = (latest: number, proven: number, finalized: number) => ({
     latest: makeTip(latest),