@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/block/{l2_block_downloader → l2_block_stream}/l2_block_stream.ts

@@ -2,16 +2,17 @@ import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 
-import type { L2Block } from '../l2_block.js';
-import type { L2BlockId, L2BlockSource, L2Tips } from '../l2_block_source.js';
+import { type L2BlockId, type L2BlockSource, makeL2BlockId } from '../l2_block_source.js';
+import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
 
 /** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
 export class L2BlockStream {
   private readonly runningPromise: RunningPromise;
   private isSyncing = false;
+  private hasStarted = false;
 
   constructor(
-    private l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'>,
+    private l2BlockSource: Pick<L2BlockSource, 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'>,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
@@ -20,6 +21,8 @@ export class L2BlockStream {
       pollIntervalMS?: number;
       batchSize?: number;
       startingBlock?: number;
+      /** Instead of downloading all blocks, only fetch the smallest subset that results in reliable reorg detection. */
+      skipFinalized?: boolean;
     } = {},
   ) {
     this.runningPromise = new RunningPromise(() => this.work(), log, this.opts.pollIntervalMS ?? 1000);
@@ -65,41 +68,63 @@ export class L2BlockStream {
 
       // Check if there was a reorg and emit a chain-pruned event if so.
       let latestBlockNumber = localTips.latest.number;
-      while (!(await this.areBlockHashesEqualAt(latestBlockNumber, { sourceCache: [sourceTips.latest] }))) {
+      const sourceCache = new BlockHashCache([sourceTips.latest]);
+      while (!(await this.areBlockHashesEqualAt(latestBlockNumber, { sourceCache }))) {
         latestBlockNumber--;
       }
+
       if (latestBlockNumber < localTips.latest.number) {
+        latestBlockNumber = 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}`);
+        }
         this.log.verbose(`Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.latest.number}.`);
-        await this.emitEvent({ type: 'chain-pruned', blockNumber: latestBlockNumber });
+        await this.emitEvent({ type: 'chain-pruned', block: makeL2BlockId(latestBlockNumber, hash) });
       }
 
       // 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);
+      }
+
+      // Only log this entry once (for sanity)
+      if (!this.hasStarted) {
         this.log.verbose(`Starting sync from block number ${latestBlockNumber}`);
+        this.hasStarted = true;
+      }
+
+      let nextBlockNumber = latestBlockNumber + 1;
+      if (this.opts.skipFinalized) {
+        // When skipping finalized blocks we need to provide reliable reorg detection while fetching as few blocks as
+        // possible. Finalized blocks cannot be reorged by definition, so we can skip most of them. We do need the very
+        // last finalized block however in order to guarantee that we will eventually find a block in which our local
+        // store matches the source.
+        // If the last finalized block is behind our local tip, there is nothing to skip.
+        nextBlockNumber = Math.max(sourceTips.finalized.number, nextBlockNumber);
       }
 
       // Request new blocks from the source.
-      while (latestBlockNumber < sourceTips.latest.number) {
-        const from = latestBlockNumber + 1;
-        const limit = Math.min(this.opts.batchSize ?? 20, sourceTips.latest.number - from + 1);
-        this.log.trace(`Requesting blocks from ${from} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getBlocks(from, limit, this.opts.proven);
+      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);
         if (blocks.length === 0) {
           break;
         }
         await this.emitEvent({ type: 'blocks-added', blocks });
-        latestBlockNumber = blocks.at(-1)!.number;
+        nextBlockNumber = blocks.at(-1)!.block.number + 1;
       }
 
       // Update the proven and finalized tips.
-      // TODO(palla/reorg): Should we emit this before passing the new blocks? This would allow world-state to skip
-      // building the data structures for the pending chain if it's unneeded.
       if (localTips.proven !== undefined && sourceTips.proven.number !== localTips.proven.number) {
-        await this.emitEvent({ type: 'chain-proven', blockNumber: sourceTips.proven.number });
+        await this.emitEvent({
+          type: 'chain-proven',
+          block: sourceTips.proven,
+        });
       }
       if (localTips.finalized !== undefined && sourceTips.finalized.number !== localTips.finalized.number) {
-        await this.emitEvent({ type: 'chain-finalized', blockNumber: sourceTips.finalized.number });
+        await this.emitEvent({ type: 'chain-finalized', block: sourceTips.finalized });
       }
     } catch (err: any) {
       if (err.name === 'AbortError') {
@@ -114,29 +139,40 @@ 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: L2BlockId[] }) {
+  private async areBlockHashesEqualAt(blockNumber: number, args: { sourceCache: BlockHashCache }) {
     if (blockNumber === 0) {
       return true;
     }
     const localBlockHash = await this.localData.getL2BlockHash(blockNumber);
-    const sourceBlockHash =
-      args.sourceCache.find(id => id.number === blockNumber && id.hash)?.hash ??
-      (await this.l2BlockSource
-        .getBlockHeader(blockNumber)
-        .then(h => h?.hash())
-        .then(hash => hash?.toString()));
-    this.log.trace(`Comparing block hashes for block ${blockNumber}`, {
-      localBlockHash,
-      sourceBlockHash,
-      sourceCacheNumber: args.sourceCache[0]?.number,
-      sourceCacheHash: args.sourceCache[0]?.hash,
-    });
+    if (!localBlockHash && this.opts.skipFinalized) {
+      // Failing to find a block hash when skipping finalized blocks can be highly problematic as we'd potentially need
+      // to go all the way back to the genesis block to find a block in which we agree with the source (since we've
+      // potentially skipped all history). This means that stores that prune old blocks must be careful to leave no gaps
+      // when going back from latest block to the last finalized one.
+      this.log.error(`No local block hash for block number ${blockNumber}`);
+      throw new AbortError();
+    }
+
+    const sourceBlockHashFromCache = args.sourceCache.get(blockNumber);
+    const sourceBlockHash = args.sourceCache.get(blockNumber) ?? (await this.getBlockHashFromSource(blockNumber));
+    if (!sourceBlockHashFromCache && sourceBlockHash) {
+      args.sourceCache.add({ number: blockNumber, hash: sourceBlockHash });
+    }
+
+    this.log.trace(`Comparing block hashes for block ${blockNumber}`, { localBlockHash, sourceBlockHash });
     return localBlockHash === sourceBlockHash;
   }
 
+  private getBlockHashFromSource(blockNumber: number) {
+    return this.l2BlockSource
+      .getBlockHeader(blockNumber)
+      .then(h => h?.hash())
+      .then(hash => hash?.toString());
+  }
+
   private async emitEvent(event: L2BlockStreamEvent) {
     this.log.debug(
-      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.blockNumber})`,
+      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.block.number})`,
     );
     await this.handler.handleBlockStreamEvent(event);
     if (!this.isRunning() && !this.isSyncing) {
@@ -145,35 +181,22 @@ export class L2BlockStream {
   }
 }
 
-/** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
-export interface L2BlockStreamLocalDataProvider {
-  getL2BlockHash(number: number): Promise<string | undefined>;
-  getL2Tips(): Promise<L2Tips>;
-}
-
-/** Interface to a handler of events emitted. */
-export interface L2BlockStreamEventHandler {
-  handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
-}
+class BlockHashCache {
+  private readonly cache: Map<number, string> = new Map();
 
-export type L2BlockStreamEvent =
-  | {
-      type: 'blocks-added';
-      /** New blocks added to the chain. */
-      blocks: L2Block[];
-    }
-  | {
-      type: 'chain-pruned';
-      /** Last correct block number (new tip of the unproven chain). */
-      blockNumber: number;
+  constructor(initial: L2BlockId[] = []) {
+    for (const block of initial) {
+      this.add(block);
     }
-  | {
-      type: 'chain-proven';
-      /** New proven block number */
-      blockNumber: number;
+  }
+
+  public add(block: L2BlockId) {
+    if (block.hash) {
+      this.cache.set(block.number, block.hash);
     }
-  | {
-      type: 'chain-finalized';
-      /** New finalized block number */
-      blockNumber: number;
-    };
+  }
+
+  public get(blockNumber: number) {
+    return this.cache.get(blockNumber);
+  }
+}

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -0,0 +1,75 @@
+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';
+
+/**
+ * Stores currently synced L2 tips and unfinalized block hashes.
+ * @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 l2BlockHashesStore: Map<number, string> = new Map();
+
+  public getL2BlockHash(number: number): Promise<string | undefined> {
+    return Promise.resolve(this.l2BlockHashesStore.get(number));
+  }
+
+  public getL2Tips(): Promise<L2Tips> {
+    return Promise.resolve({
+      latest: this.getL2Tip('latest'),
+      finalized: this.getL2Tip('finalized'),
+      proven: this.getL2Tip('proven'),
+    });
+  }
+
+  private getL2Tip(tag: L2BlockTag): L2BlockId {
+    const blockNumber = this.l2TipsStore.get(tag);
+    if (blockNumber === undefined || blockNumber === 0) {
+      return { number: 0, hash: undefined };
+    }
+    const blockHash = this.l2BlockHashesStore.get(blockNumber);
+    if (!blockHash) {
+      throw new Error(`Block hash not found for block number ${blockNumber}`);
+    }
+
+    return { number: blockNumber, hash: blockHash };
+  }
+
+  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+    switch (event.type) {
+      case 'blocks-added': {
+        const blocks = event.blocks.map(b => b.block);
+        for (const block of blocks) {
+          this.l2BlockHashesStore.set(block.number, await this.computeBlockHash(block));
+        }
+        this.l2TipsStore.set('latest', blocks.at(-1)!.number);
+        break;
+      }
+      case 'chain-pruned':
+        this.saveTag('latest', event.block);
+        break;
+      case 'chain-proven':
+        this.saveTag('proven', event.block);
+        break;
+      case 'chain-finalized':
+        this.saveTag('finalized', event.block);
+        for (const key of this.l2BlockHashesStore.keys()) {
+          if (key < event.block.number) {
+            this.l2BlockHashesStore.delete(key);
+          }
+        }
+        break;
+    }
+  }
+
+  protected saveTag(name: L2BlockTag, block: L2BlockId) {
+    this.l2TipsStore.set(name, block.number);
+    if (block.hash) {
+      this.l2BlockHashesStore.set(block.number, block.hash);
+    }
+  }
+
+  protected computeBlockHash(block: L2Block) {
+    return block.hash().then(hash => hash.toString());
+  }
+}

package/src/block/proposal/attestations_and_signers.ts

@@ -0,0 +1,121 @@
+import type { ViemCommitteeAttestations } from '@aztec/ethereum';
+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 } 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')}`,
+    };
+  }
+}

package/src/block/proposal/committee_attestation.ts

@@ -0,0 +1,120 @@
+import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+export { EthAddress, Signature };
+
+export class CommitteeAttestation {
+  constructor(
+    public readonly address: EthAddress,
+    public readonly signature: Signature,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        address: EthAddress.schema,
+        signature: Signature.schema,
+      })
+      .transform(({ address, signature }) => new CommitteeAttestation(address, signature));
+  }
+
+  // Create an empty attestation for an address that has not signed
+  static fromAddress(address: EthAddress): CommitteeAttestation {
+    return new CommitteeAttestation(address, Signature.empty());
+  }
+
+  // Create an attestation from an address and a signature
+  static fromAddressAndSignature(address: EthAddress, signature: Signature): CommitteeAttestation {
+    return new CommitteeAttestation(address, signature);
+  }
+
+  static fromSignature(signature: Signature): CommitteeAttestation {
+    return new CommitteeAttestation(EthAddress.ZERO, signature);
+  }
+
+  static fromViem(viem: ViemCommitteeAttestation): CommitteeAttestation {
+    return new CommitteeAttestation(EthAddress.fromString(viem.addr), Signature.fromViemSignature(viem.signature));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): CommitteeAttestation {
+    const reader = BufferReader.asReader(buffer);
+    const address = reader.readObject(EthAddress);
+    const signature = reader.readObject(Signature);
+    return new CommitteeAttestation(address, signature);
+  }
+
+  static random(): CommitteeAttestation {
+    // note: will be invalid
+    return new CommitteeAttestation(EthAddress.random(), Signature.random());
+  }
+
+  static empty(): CommitteeAttestation {
+    return new CommitteeAttestation(EthAddress.ZERO, Signature.empty());
+  }
+
+  static fromPacked(packed: ViemCommitteeAttestations, committeeSize: number): CommitteeAttestation[] {
+    const signatureIndicesBuffer = Buffer.from(packed.signatureIndices.slice(2), 'hex');
+    const dataBuffer = Buffer.from(packed.signaturesOrAddresses.slice(2), 'hex');
+
+    const attestations: CommitteeAttestation[] = [];
+    let dataIndex = 0;
+
+    for (let i = 0; i < committeeSize; i++) {
+      // Check if this position has a signature
+      const byteIndex = Math.floor(i / 8);
+      const bitIndex = 7 - (i % 8);
+      const hasSignature =
+        byteIndex < signatureIndicesBuffer.length && (signatureIndicesBuffer[byteIndex] & (1 << bitIndex)) !== 0;
+
+      if (hasSignature) {
+        // Extract signature: v (1 byte) + r (32 bytes) + s (32 bytes)
+        if (dataIndex + 65 > dataBuffer.length) {
+          throw new Error(`Insufficient data for signature at position ${i}`);
+        }
+
+        const v = dataBuffer[dataIndex];
+        const r = `0x${dataBuffer.subarray(dataIndex + 1, dataIndex + 33).toString('hex')}` as const;
+        const s = `0x${dataBuffer.subarray(dataIndex + 33, dataIndex + 65).toString('hex')}` as const;
+
+        const signature = Signature.fromViemSignature({ r, s, v });
+
+        // For signed attestations, we use a zero address as the address is recovered from the signature
+        attestations.push(new CommitteeAttestation(EthAddress.ZERO, signature));
+        dataIndex += 65;
+      } else {
+        // Extract address (20 bytes)
+        if (dataIndex + 20 > dataBuffer.length) {
+          throw new Error(`Insufficient data for address at position ${i}`);
+        }
+
+        const addressBytes = dataBuffer.subarray(dataIndex, dataIndex + 20);
+        const address = EthAddress.fromString(`0x${addressBytes.toString('hex')}`);
+
+        // For address-only attestations, use empty signature
+        attestations.push(new CommitteeAttestation(address, Signature.empty()));
+        dataIndex += 20;
+      }
+    }
+
+    return attestations;
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.address, this.signature]);
+  }
+
+  equals(other: CommitteeAttestation): boolean {
+    return this.address.equals(other.address) && this.signature.equals(other.signature);
+  }
+
+  toViem(): ViemCommitteeAttestation {
+    return {
+      addr: this.address.toString(),
+      signature: this.signature.toViemSignature(),
+    };
+  }
+}

package/src/block/proposal/index.ts

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

package/src/block/published_l2_block.ts

@@ -0,0 +1,82 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
+
+export class L1PublishedData {
+  constructor(
+    public blockNumber: bigint,
+    public timestamp: bigint,
+    public blockHash: string,
+  ) {}
+
+  static get schema() {
+    return z.object({
+      blockNumber: schemas.BigInt,
+      timestamp: schemas.BigInt,
+      blockHash: z.string(),
+    });
+  }
+
+  static random() {
+    return new L1PublishedData(
+      randomBigInt(1000n) + 1n,
+      BigInt(Math.floor(Date.now() / 1000)),
+      Buffer32.random().toString(),
+    );
+  }
+
+  static fromFields(fields: FieldsOf<L1PublishedData>) {
+    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+  }
+}
+
+export class PublishedL2Block {
+  constructor(
+    public block: L2Block,
+    public l1: L1PublishedData,
+    public attestations: CommitteeAttestation[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        block: L2Block.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedL2Block.fromFields(obj));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedL2Block {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const block = reader.readObject(L2Block);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    return new PublishedL2Block(block, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
+  }
+
+  static fromFields(fields: FieldsOf<PublishedL2Block>) {
+    return new PublishedL2Block(fields.block, fields.l1, fields.attestations);
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.block,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/block/test/index.ts

@@ -0,0 +1 @@
+export * from './l2_tips_store_test_suite.js';