@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/block/l2_block_header.ts

@@ -1,3 +1,4 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
@@ -36,6 +37,8 @@ export class L2BlockHeader {
     public totalManaUsed: Fr,
     /** Hash of the sponge blob of the block. */
     public spongeBlobHash: Fr,
+    /** Hash of the block headers in the checkpoint. */
+    public blockHeadersHash: Fr,
   ) {}
 
   static get schema(): ZodFor<L2BlockHeader> {
@@ -48,6 +51,7 @@ export class L2BlockHeader {
         totalFees: schemas.Fr,
         totalManaUsed: schemas.Fr,
         spongeBlobHash: schemas.Fr,
+        blockHeadersHash: schemas.Fr,
       })
       .transform(L2BlockHeader.from);
   }
@@ -61,6 +65,7 @@ export class L2BlockHeader {
       fields.totalFees,
       fields.totalManaUsed,
       fields.spongeBlobHash,
+      fields.blockHeadersHash,
     ] as const;
   }
 
@@ -68,8 +73,8 @@ export class L2BlockHeader {
     return new L2BlockHeader(...L2BlockHeader.getFields(fields));
   }
 
-  getSlot() {
-    return this.globalVariables.slotNumber.toBigInt();
+  getSlot(): SlotNumber {
+    return this.globalVariables.slotNumber;
   }
 
   getBlockNumber() {
@@ -84,7 +89,8 @@ export class L2BlockHeader {
       this.globalVariables.getSize() +
       this.totalFees.size +
       this.totalManaUsed.size +
-      this.spongeBlobHash.size
+      this.spongeBlobHash.size +
+      this.blockHeadersHash.size
     );
   }
 
@@ -111,6 +117,7 @@ export class L2BlockHeader {
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readObject(Fr),
+      reader.readObject(Fr),
     );
   }
 
@@ -125,6 +132,7 @@ export class L2BlockHeader {
       reader.readField(),
       reader.readField(),
       reader.readField(),
+      reader.readField(),
     );
   }
 
@@ -137,6 +145,7 @@ export class L2BlockHeader {
       totalFees: Fr.ZERO,
       totalManaUsed: Fr.ZERO,
       spongeBlobHash: Fr.ZERO,
+      blockHeadersHash: Fr.ZERO,
       ...fields,
     });
   }
@@ -149,7 +158,8 @@ export class L2BlockHeader {
       this.globalVariables.isEmpty() &&
       this.totalFees.isZero() &&
       this.totalManaUsed.isZero() &&
-      this.spongeBlobHash.isZero()
+      this.spongeBlobHash.isZero() &&
+      this.blockHeadersHash.isZero()
     );
   }
 
@@ -168,6 +178,7 @@ export class L2BlockHeader {
   toCheckpointHeader() {
     return new CheckpointHeader(
       this.lastArchive.root,
+      this.blockHeadersHash,
       this.contentCommitment,
       this.globalVariables.slotNumber,
       this.globalVariables.timestamp,
@@ -198,6 +209,7 @@ export class L2BlockHeader {
       totalFees: this.totalFees.toBigInt(),
       totalManaUsed: this.totalManaUsed.toBigInt(),
       spongeBlobHash: this.spongeBlobHash.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
     };
   }
 
@@ -215,6 +227,7 @@ export class L2BlockHeader {
   totalFees: ${this.totalFees},
   totalManaUsed: ${this.totalManaUsed},
   spongeBlobHash: ${this.spongeBlobHash},
+  blockHeadersHash: ${this.blockHeadersHash},
 }`;
   }
 
@@ -226,7 +239,8 @@ export class L2BlockHeader {
       this.totalFees.equals(other.totalFees) &&
       this.totalManaUsed.equals(other.totalManaUsed) &&
       this.lastArchive.equals(other.lastArchive) &&
-      this.spongeBlobHash.equals(other.spongeBlobHash)
+      this.spongeBlobHash.equals(other.spongeBlobHash) &&
+      this.blockHeadersHash.equals(other.blockHeadersHash)
     );
   }
 }

package/src/block/l2_block_info.ts

@@ -1,3 +1,4 @@
+import { BlockNumber, BlockNumberSchema, SlotNumber, SlotNumberSchema } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -8,19 +9,19 @@ export type L2BlockInfo = {
   blockHash?: Fr;
   archive: Fr;
   lastArchive: Fr;
-  blockNumber: number;
-  slotNumber: number;
+  blockNumber: BlockNumber;
+  slotNumber: SlotNumber;
   txCount: number;
   timestamp: bigint;
 };
 
-export function randomBlockInfo(blockNumber?: number): L2BlockInfo {
+export function randomBlockInfo(blockNumber?: BlockNumber | number): L2BlockInfo {
   return {
     blockHash: Fr.random(),
     archive: Fr.random(),
     lastArchive: Fr.random(),
-    blockNumber: blockNumber ?? Math.floor(Math.random() * 100000) + 1,
-    slotNumber: Math.floor(Math.random() * 100000) + 1,
+    blockNumber: BlockNumber(blockNumber ?? Math.floor(Math.random() * 100000) + 1),
+    slotNumber: SlotNumber(Math.floor(Math.random() * 100000) + 1),
     txCount: Math.floor(Math.random() * 100),
     timestamp: BigInt(Math.floor(Date.now() / 1000)),
   };
@@ -30,8 +31,8 @@ export const BlockInfoSchema = z.object({
   blockHash: schemas.Fr.optional(),
   archive: schemas.Fr,
   lastArchive: schemas.Fr,
-  blockNumber: z.number(),
-  slotNumber: z.number(),
+  blockNumber: BlockNumberSchema,
+  slotNumber: SlotNumberSchema,
   txCount: z.number(),
   timestamp: schemas.BigInt,
 });
@@ -55,8 +56,8 @@ export function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo
     blockHash: blockHash.equals(Fr.ZERO) ? undefined : blockHash,
     archive: reader.readObject(Fr),
     lastArchive: reader.readObject(Fr),
-    blockNumber: reader.readNumber(),
-    slotNumber: reader.readNumber(),
+    blockNumber: BlockNumber(reader.readNumber()),
+    slotNumber: SlotNumber(reader.readNumber()),
     txCount: reader.readNumber(),
     timestamp: reader.readBigInt(),
   };

package/src/block/l2_block_new.ts

@@ -0,0 +1,176 @@
+import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { Body } from './body.js';
+import type { L2BlockInfo } from './l2_block_info.js';
+
+/**
+ * An L2 block with a header and a body.
+ * TODO: Delete the existing `L2Block` class and rename this to `L2Block`.
+ */
+export class L2BlockNew {
+  constructor(
+    /** Snapshot of archive tree after the block is applied. */
+    public archive: AppendOnlyTreeSnapshot,
+    /** Header of the block. */
+    public header: BlockHeader,
+    /** L2 block body. */
+    public body: Body,
+    private blockHash: Fr | undefined = undefined,
+  ) {}
+
+  get number(): BlockNumber {
+    return this.header.globalVariables.blockNumber;
+  }
+
+  get timestamp(): bigint {
+    return this.header.globalVariables.timestamp;
+  }
+
+  static get schema() {
+    return z
+      .object({
+        archive: AppendOnlyTreeSnapshot.schema,
+        header: BlockHeader.schema,
+        body: Body.schema,
+      })
+      .transform(({ archive, header, body }) => new L2BlockNew(archive, header, body));
+  }
+
+  /**
+   * Deserializes a block from a buffer
+   * @returns A deserialized L2 block.
+   */
+  static fromBuffer(buf: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buf);
+    const header = reader.readObject(BlockHeader);
+    const archive = reader.readObject(AppendOnlyTreeSnapshot);
+    const body = reader.readObject(Body);
+
+    return new L2BlockNew(archive, header, body);
+  }
+
+  /**
+   * Serializes a block
+   * @returns A serialized L2 block as a Buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.header, this.archive, this.body);
+  }
+
+  /**
+   * Returns the block's hash (hash of block header).
+   * @returns The block's hash.
+   */
+  public async hash(): Promise<Fr> {
+    if (this.blockHash === undefined) {
+      this.blockHash = await this.header.hash();
+    }
+    return this.blockHash;
+  }
+
+  public toBlobFields(isFirstBlock: boolean): Fr[] {
+    const blockBlobData = this.toBlockBlobData(isFirstBlock);
+    return encodeBlockBlobData(blockBlobData);
+  }
+
+  public toBlockBlobData(isFirstBlock: boolean): BlockBlobData {
+    return {
+      blockEndMarker: {
+        numTxs: this.body.txEffects.length,
+        timestamp: this.header.globalVariables.timestamp,
+        blockNumber: this.number,
+      },
+      blockEndStateField: {
+        l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
+        noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
+        nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
+        publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
+        totalManaUsed: this.header.totalManaUsed.toBigInt(),
+      },
+      lastArchiveRoot: this.header.lastArchive.root,
+      noteHashRoot: this.header.state.partial.noteHashTree.root,
+      nullifierRoot: this.header.state.partial.nullifierTree.root,
+      publicDataRoot: this.header.state.partial.publicDataTree.root,
+      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
+      txs: this.body.toTxBlobData(),
+    };
+  }
+
+  static empty() {
+    return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty());
+  }
+
+  /**
+   * Creates an L2 block containing random data.
+   * @param l2BlockNum - The number of the L2 block.
+   * @param txsPerBlock - The number of transactions to include in the block.
+   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
+   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
+   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
+   * @returns The L2 block.
+   */
+  static async random(
+    blockNumber: BlockNumber,
+    {
+      txsPerBlock = 1,
+      txOptions = {},
+      makeTxOptions,
+      ...blockHeaderOverrides
+    }: {
+      txsPerBlock?: number;
+      txOptions?: Partial<Parameters<typeof Body.random>[0]>;
+      makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
+    } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
+  ): Promise<L2BlockNew> {
+    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
+    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
+    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
+    return new L2BlockNew(archive, header, body);
+  }
+
+  /**
+   * Returns stats used for logging.
+   * @returns Stats on tx count, number, and log size and count.
+   */
+  getStats() {
+    const logsStats = {
+      privateLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.privateLogs.length, 0),
+      publicLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.publicLogs.length, 0),
+      contractClassLogCount: this.body.txEffects.reduce(
+        (logCount, txEffect) => logCount + txEffect.contractClassLogs.length,
+        0,
+      ),
+      contractClassLogSize: this.body.txEffects.reduce(
+        (totalLogSize, txEffect) =>
+          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
+        0,
+      ),
+    };
+
+    return {
+      txCount: this.body.txEffects.length,
+      blockNumber: this.number,
+      blockTimestamp: Number(this.header.globalVariables.timestamp),
+      ...logsStats,
+    };
+  }
+
+  toBlockInfo(): L2BlockInfo {
+    return {
+      blockHash: this.blockHash,
+      archive: this.archive.root,
+      lastArchive: this.header.lastArchive.root,
+      blockNumber: this.number,
+      slotNumber: this.header.getSlot(),
+      txCount: this.body.txEffects.length,
+      timestamp: this.header.globalVariables.timestamp,
+    };
+  }
+}

package/src/block/l2_block_source.ts

@@ -1,9 +1,18 @@
+import {
+  BlockNumber,
+  BlockNumberSchema,
+  type CheckpointNumber,
+  type EpochNumber,
+  type SlotNumber,
+} from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 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 type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
@@ -33,27 +42,27 @@ 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>;
+  getProvenBlockNumber(): Promise<BlockNumber>;
 
   /**
    * 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>;
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
 
   /**
    * 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`.
@@ -62,10 +71,20 @@ export interface L2BlockSource {
    * @param proven - If true, only return blocks that have been proven.
    * @returns The requested L2 blocks.
    */
-  getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
+  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
+
+  getPublishedCheckpoints(from: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+
+  /**
+   * Gets a checkpoint by the archive root, which should be the root of the archive tree after the requested checkpoint
+   * is applied.
+   * @param archive - The new archive root of the checkpoint.
+   * @returns The requested checkpoint (or undefined if not found).
+   */
+  getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined>;
 
   /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
 
   /**
    * Gets a published block by its hash.
@@ -112,32 +131,39 @@ export interface L2BlockSource {
   /**
    * Returns the current L2 slot number based on the currently synced L1 timestamp.
    */
-  getL2SlotNumber(): Promise<bigint | undefined>;
+  getL2SlotNumber(): Promise<SlotNumber | undefined>;
 
   /**
    * Returns the current L2 epoch number based on the currently synced L1 timestamp.
    */
-  getL2EpochNumber(): Promise<bigint | undefined>;
+  getL2EpochNumber(): Promise<EpochNumber | undefined>;
+
+  /**
+   * Returns all checkpoints for a given epoch.
+   * @dev Use this method only with recent epochs, since it walks the checkpoint list backwards.
+   * @param epochNumber - The epoch number to return checkpoints for.
+   */
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
 
   /**
    * 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[]>;
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
 
   /**
    * 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.
@@ -194,33 +220,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',
@@ -230,14 +249,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/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';
@@ -74,7 +75,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 +86,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 +109,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 +144,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 +168,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) {

package/src/block/proposal/attestations_and_signers.ts

@@ -5,7 +5,7 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { Signable, SignatureDomainSeparator } from '../../p2p/signature_utils.js';
-import { CommitteeAttestation } from './committee_attestation.js';
+import { CommitteeAttestation, EthAddress } from './committee_attestation.js';
 
 export class CommitteeAttestationsAndSigners implements Signable {
   constructor(public attestations: CommitteeAttestation[]) {}
@@ -119,3 +119,22 @@ export class CommitteeAttestationsAndSigners implements Signable {
     };
   }
 }
+
+/**
+ * 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;
+  }
+}