@aztec/stdlib 0.0.1-commit.c7c42ec → 0.0.1-commit.c80b6263

package/src/block/block_hash.ts

@@ -5,7 +5,7 @@ import { BufferReader } from '@aztec/foundation/serialize';
 import { schemas } from '../schemas/schemas.js';
 
 /** Hash of an L2 block. */
-export class L2BlockHash extends Buffer32 {
+export class BlockHash extends Buffer32 {
   constructor(
     /** The buffer containing the hash. */
     hash: Buffer,
@@ -13,32 +13,58 @@ export class L2BlockHash extends Buffer32 {
     super(hash);
   }
 
+  /**
+   * Type guard that checks if a value is an BlockHash instance.
+   * Uses duck typing to handle cases where instanceof fails due to module duplication.
+   * Checks for Buffer32-like structure with a 32-byte buffer.
+   */
+  static isL2BlockHash(value: unknown): value is BlockHash {
+    if (value instanceof BlockHash) {
+      return true;
+    }
+    // Duck typing fallback: check if it looks like a Buffer32 with a 32-byte buffer
+    // This helps when instanceof fails due to module duplication
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      'buffer' in value &&
+      Buffer.isBuffer((value as Buffer32).buffer) &&
+      (value as Buffer32).buffer.length === 32 &&
+      'toBuffer' in value &&
+      typeof (value as Buffer32).toBuffer === 'function'
+    );
+  }
+
   static override random() {
-    return new L2BlockHash(Fr.random().toBuffer());
+    return new BlockHash(Fr.random().toBuffer());
   }
 
-  static override fromNumber(num: number): L2BlockHash {
-    return new L2BlockHash(super.fromNumber(num).toBuffer());
+  static override fromNumber(num: number): BlockHash {
+    return new BlockHash(super.fromNumber(num).toBuffer());
   }
 
   static override fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new L2BlockHash(reader.readBytes(L2BlockHash.SIZE));
+    return new BlockHash(reader.readBytes(BlockHash.SIZE));
   }
 
-  static override fromString(str: string): Buffer32 {
-    return new L2BlockHash(super.fromString(str).toBuffer());
+  static override fromString(str: string): BlockHash {
+    return new BlockHash(super.fromString(str).toBuffer());
   }
 
   static get schema() {
-    return schemas.BufferHex.transform(value => new L2BlockHash(value));
+    return schemas.BufferHex.transform(value => new BlockHash(value));
   }
 
   static zero() {
-    return new L2BlockHash(Buffer32.ZERO.toBuffer());
+    return new BlockHash(Buffer32.ZERO.toBuffer());
   }
 
   static override fromField(hash: Fr) {
-    return new L2BlockHash(hash.toBuffer());
+    return new BlockHash(hash.toBuffer());
+  }
+
+  toField(): Fr {
+    return Fr.fromBuffer(this.toBuffer());
   }
 }

package/src/block/block_parameter.ts

@@ -2,7 +2,9 @@ import { BlockNumberSchema } from '@aztec/foundation/branded-types';
 
 import { z } from 'zod';
 
-export const BlockParameterSchema = z.union([BlockNumberSchema, z.literal('latest')]);
+import { BlockHash } from './block_hash.js';
 
-/** Block parameter - either a specific BlockNumber or 'latest' */
+export const BlockParameterSchema = z.union([BlockHash.schema, BlockNumberSchema, z.literal('latest')]);
+
+/** Block parameter - either a specific BlockNumber, block hash (BlockHash), or 'latest' */
 export type BlockParameter = z.infer<typeof BlockParameterSchema>;

package/src/block/body.ts

@@ -5,6 +5,7 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import { MAX_TX_EFFECTS_PER_BODY } from '../deserialization/index.js';
 import type { ZodFor } from '../schemas/index.js';
 import { TxEffect } from '../tx/tx_effect.js';
 
@@ -40,7 +41,7 @@ export class Body {
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
 
-    return new this(reader.readVector(TxEffect));
+    return new this(reader.readVector(TxEffect, MAX_TX_EFFECTS_PER_BODY));
   }
 
   /**

package/src/block/checkpointed_l2_block.ts

@@ -5,9 +5,9 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
+import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
 import { L2Block } from './l2_block.js';
-import { L2BlockNew } from './l2_block_new.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
@@ -16,7 +16,7 @@ import { CommitteeAttestation } from './proposal/committee_attestation.js';
 export class CheckpointedL2Block {
   constructor(
     public checkpointNumber: CheckpointNumber,
-    public block: L2BlockNew,
+    public block: L2Block,
     public l1: L1PublishedData,
     public attestations: CommitteeAttestation[],
   ) {}
@@ -24,7 +24,7 @@ export class CheckpointedL2Block {
     return z
       .object({
         checkpointNumber: CheckpointNumberSchema,
-        block: L2BlockNew.schema,
+        block: L2Block.schema,
         l1: L1PublishedData.schema,
         attestations: z.array(CommitteeAttestation.schema),
       })
@@ -34,11 +34,11 @@ export class CheckpointedL2Block {
   static fromBuffer(bufferOrReader: Buffer | BufferReader): CheckpointedL2Block {
     const reader = BufferReader.asReader(bufferOrReader);
     const checkpointNumber = reader.readNumber();
-    const block = reader.readObject(L2BlockNew);
+    const block = reader.readObject(L2Block);
     const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();
-    const attestations = reader.readVector(CommitteeAttestation);
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
     return new CheckpointedL2Block(
       CheckpointNumber(checkpointNumber),
       block,
@@ -58,6 +58,7 @@ export class CheckpointedL2Block {
 
   public toBuffer(): Buffer {
     return serializeToBuffer(
+      this.checkpointNumber,
       this.block,
       this.l1.blockNumber,
       this.l1.blockHash,
@@ -67,54 +68,3 @@ export class CheckpointedL2Block {
     );
   }
 }
-
-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,
-    );
-  }
-
-  public toPublishedCheckpoint() {
-    return new PublishedCheckpoint(this.block.toCheckpoint(), this.l1, this.attestations);
-  }
-
-  static fromPublishedCheckpoint(checkpoint: PublishedCheckpoint) {
-    return new PublishedL2Block(L2Block.fromCheckpoint(checkpoint.checkpoint), checkpoint.l1, checkpoint.attestations);
-  }
-}

package/src/block/in_block.ts

@@ -2,12 +2,12 @@ import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types'
 
 import { type ZodTypeAny, z } from 'zod';
 
-import { L2BlockHash } from './block_hash.js';
+import { BlockHash } from './block_hash.js';
 import type { L2Block } from './l2_block.js';
 
 export type InBlock = {
   l2BlockNumber: BlockNumber;
-  l2BlockHash: L2BlockHash;
+  l2BlockHash: BlockHash;
 };
 
 // Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
@@ -18,7 +18,7 @@ export type DataInBlock<T> = {
 export function randomInBlock(): InBlock {
   return {
     l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000)),
-    l2BlockHash: L2BlockHash.random(),
+    l2BlockHash: BlockHash.random(),
   };
 }
 
@@ -33,14 +33,14 @@ export async function wrapDataInBlock<T>(data: T, block: L2Block): Promise<DataI
   return {
     data,
     l2BlockNumber: block.number,
-    l2BlockHash: L2BlockHash.fromField(await block.hash()),
+    l2BlockHash: BlockHash.fromField(await block.hash()),
   };
 }
 
 export function inBlockSchema() {
   return z.object({
     l2BlockNumber: BlockNumberSchema,
-    l2BlockHash: L2BlockHash.schema,
+    l2BlockHash: BlockHash.schema,
   });
 }
 

package/src/block/index.ts

@@ -1,6 +1,4 @@
 export * from './l2_block.js';
-export * from './l2_block_new.js';
-export * from './l2_block_header.js';
 export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';

package/src/block/l2_block.ts

@@ -1,44 +1,65 @@
-import { type BlockBlobData, encodeBlockBlobData, encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
-import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  IndexWithinCheckpoint,
+  IndexWithinCheckpointSchema,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
-import { Checkpoint } from '../checkpoint/checkpoint.js';
+import type { PrivateLog } from '../logs/private_log.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import type { BlockHeader } from '../tx/block_header.js';
+import { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
-import { makeAppendOnlyTreeSnapshot, makeL2BlockHeader } from './l2_block_code_to_purge.js';
-import { L2BlockHeader } from './l2_block_header.js';
 import type { L2BlockInfo } from './l2_block_info.js';
-import { L2BlockNew } from './l2_block_new.js';
 
 /**
- * The data that makes up the rollup proof, with encoder decoder functions.
- *
- * @deprecated Use `L2BlockNew` instead.
+ * An L2 block with a header and a body.
  */
 export class L2Block {
   constructor(
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
-    /** L2 block header. */
-    public header: L2BlockHeader,
+    /** Header of the block. */
+    public header: BlockHeader,
     /** L2 block body. */
     public body: Body,
-    private blockHash: Fr | undefined = undefined,
+    /** Number of the checkpoint that the block belongs to. */
+    public checkpointNumber: CheckpointNumber,
+    /** Index of the block within the checkpoint. */
+    public indexWithinCheckpoint: IndexWithinCheckpoint,
   ) {}
 
+  get number(): BlockNumber {
+    return this.header.globalVariables.blockNumber;
+  }
+
+  get slot(): SlotNumber {
+    return this.header.globalVariables.slotNumber;
+  }
+
+  get timestamp(): bigint {
+    return this.header.globalVariables.timestamp;
+  }
+
   static get schema() {
     return z
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
-        header: L2BlockHeader.schema,
+        header: BlockHeader.schema,
         body: Body.schema,
+        checkpointNumber: CheckpointNumberSchema,
+        indexWithinCheckpoint: IndexWithinCheckpointSchema,
       })
-      .transform(({ archive, header, body }) => new L2Block(archive, header, body));
+      .transform(
+        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
+          new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+      );
   }
 
   /**
@@ -47,11 +68,13 @@ export class L2Block {
    */
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
-    const header = reader.readObject(L2BlockHeader);
+    const header = reader.readObject(BlockHeader);
     const archive = reader.readObject(AppendOnlyTreeSnapshot);
     const body = reader.readObject(Body);
+    const checkpointNumber = CheckpointNumber(reader.readNumber());
+    const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
 
-    return new L2Block(archive, header, body);
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -59,71 +82,7 @@ export class L2Block {
    * @returns A serialized L2 block as a Buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.header, this.archive, this.body);
-  }
-
-  /**
-   * Deserializes L2 block from a buffer.
-   * @param str - A serialized L2 block.
-   * @returns Deserialized L2 block.
-   */
-  static fromString(str: string): L2Block {
-    return L2Block.fromBuffer(hexToBuffer(str));
-  }
-
-  /**
-   * Serializes a block to a string.
-   * @returns A serialized L2 block as a string.
-   */
-  toString(): string {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * 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(
-    l2BlockNum: BlockNumber,
-    txsPerBlock = 4,
-    numPublicCallsPerTx = 3,
-    numPublicLogsPerCall = 1,
-    inHash: Fr | undefined = undefined,
-    slotNumber: number | undefined = undefined,
-    maxEffects: number | undefined = undefined,
-  ): Promise<L2Block> {
-    const body = await Body.random({ txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects });
-
-    return new L2Block(
-      makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
-      makeL2BlockHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, {}, inHash),
-      body,
-    );
-  }
-
-  /**
-   * Creates an L2 block containing empty data.
-   * @returns The L2 block.
-   */
-  static empty(): L2Block {
-    return new L2Block(AppendOnlyTreeSnapshot.empty(), L2BlockHeader.empty(), Body.empty());
-  }
-
-  get number(): BlockNumber {
-    return this.header.getBlockNumber();
-  }
-
-  get slot(): SlotNumber {
-    return this.header.getSlot();
-  }
-
-  get timestamp(): bigint {
-    return this.header.globalVariables.timestamp;
+    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
   }
 
   /**
@@ -131,79 +90,32 @@ export class L2Block {
    * @returns The block's hash.
    */
   public async hash(): Promise<Fr> {
-    if (this.blockHash === undefined) {
-      this.blockHash = await this.getBlockHeader().hash();
-    }
-    return this.blockHash;
+    const blockHash = await this.header.hash();
+    return blockHash.toField();
   }
 
   /**
-   * @deprecated
-   * This only works when there's one block per checkpoint.
-   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
+   * Checks if this block equals another block.
+   * @param other - The other block to compare with.
+   * @returns True if both blocks are equal.
    */
-  public getCheckpointHeader() {
-    return this.header.toCheckpointHeader();
-  }
-
-  // Temporary helper to get the actual block header.
-  public getBlockHeader(): BlockHeader {
-    return this.header.toBlockHeader();
-  }
-
-  public toL2Block() {
-    return new L2BlockNew(
-      this.archive,
-      this.getBlockHeader(),
-      this.body,
-      CheckpointNumber.fromBlockNumber(this.number),
-      0, // indexWithinCheckpoint
+  public equals(other: this): boolean {
+    return (
+      this.archive.equals(other.archive) &&
+      this.header.equals(other.header) &&
+      this.body.equals(other.body) &&
+      this.checkpointNumber === other.checkpointNumber &&
+      this.indexWithinCheckpoint === other.indexWithinCheckpoint
     );
   }
 
-  public toCheckpoint() {
-    return new Checkpoint(
-      this.archive,
-      this.getCheckpointHeader(),
-      [this.toL2Block()],
-      CheckpointNumber.fromBlockNumber(this.number),
-    );
-  }
-
-  static fromCheckpoint(checkpoint: Checkpoint) {
-    const checkpointHeader = checkpoint.header;
-    const block = checkpoint.blocks.at(-1)!;
-    const header = new L2BlockHeader(
-      new AppendOnlyTreeSnapshot(checkpointHeader.lastArchiveRoot, block.number),
-      checkpointHeader.contentCommitment,
-      block.header.state,
-      block.header.globalVariables,
-      block.header.totalFees,
-      checkpointHeader.totalManaUsed,
-      block.header.spongeBlobHash,
-      checkpointHeader.blockHeadersHash,
-    );
-    return new L2Block(checkpoint.archive, header, block.body);
-  }
-
-  /**
-   * @deprecated
-   * This only works when there's one block per checkpoint.
-   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
-   */
-  public getCheckpointBlobFields() {
-    const blockBlobData = this.toBlockBlobData();
-    return encodeCheckpointBlobDataFromBlocks([blockBlobData]);
-  }
-
   public toBlobFields(): Fr[] {
     const blockBlobData = this.toBlockBlobData();
     return encodeBlockBlobData(blockBlobData);
   }
 
   public toBlockBlobData(): BlockBlobData {
-    // There's only one L2Block per checkpoint, so it's always the first block in the checkpoint.
-    const isFirstBlock = true;
+    const isFirstBlock = this.indexWithinCheckpoint === 0;
     return {
       blockEndMarker: {
         numTxs: this.body.txEffects.length,
@@ -226,6 +138,48 @@ export class L2Block {
     };
   }
 
+  static empty(header?: BlockHeader) {
+    return new L2Block(
+      AppendOnlyTreeSnapshot.empty(),
+      header ?? BlockHeader.empty(),
+      Body.empty(),
+      CheckpointNumber(0),
+      IndexWithinCheckpoint(0),
+    );
+  }
+
+  /**
+   * 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,
+    {
+      checkpointNumber = CheckpointNumber(Number(blockNumber)),
+      indexWithinCheckpoint = IndexWithinCheckpoint(0),
+      txsPerBlock = 1,
+      txOptions = {},
+      makeTxOptions,
+      ...blockHeaderOverrides
+    }: {
+      checkpointNumber?: CheckpointNumber;
+      indexWithinCheckpoint?: IndexWithinCheckpoint;
+      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<L2Block> {
+    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
+    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
+    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+  }
+
   /**
    * Returns stats used for logging.
    * @returns Stats on tx count, number, and log size and count.
@@ -253,9 +207,12 @@ export class L2Block {
     };
   }
 
+  getPrivateLogs(): PrivateLog[] {
+    return this.body.txEffects.map(txEffect => txEffect.privateLogs).flat();
+  }
+
   toBlockInfo(): L2BlockInfo {
     return {
-      blockHash: this.blockHash,
       archive: this.archive.root,
       lastArchive: this.header.lastArchive.root,
       blockNumber: this.number,
@@ -264,8 +221,4 @@ export class L2Block {
       timestamp: this.header.globalVariables.timestamp,
     };
   }
-
-  equals(other: L2Block) {
-    return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body);
-  }
 }