@aztec/stdlib 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/src/block/block_hash.ts

@@ -1,70 +1,52 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader } from '@aztec/foundation/serialize';
+import { GENESIS_BLOCK_HEADER_HASH as GENESIS_BLOCK_HEADER_HASH_FR } from '@aztec/constants';
+import { BaseFr, Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import type { BufferReader } from '@aztec/foundation/serialize';
 
-import { schemas } from '../schemas/schemas.js';
+import { inspect } from 'util';
+
+import { hexSchemaFor } from '../schemas/schemas.js';
 
 /** Hash of an L2 block. */
-export class BlockHash extends Buffer32 {
-  constructor(
-    /** The buffer containing the hash. */
-    hash: Buffer,
-  ) {
-    super(hash);
-  }
+export class BlockHash extends BaseFr {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'BlockHash';
 
-  /**
-   * 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 ZERO = new BlockHash(Fr.ZERO);
 
-  static override random() {
-    return new BlockHash(Fr.random().toBuffer());
+  constructor(hash: Fr) {
+    super(hash);
   }
 
-  static override fromNumber(num: number): BlockHash {
-    return new BlockHash(super.fromNumber(num).toBuffer());
+  [inspect.custom]() {
+    return `BlockHash<${this.toString()}>`;
   }
 
-  static override fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new BlockHash(reader.readBytes(BlockHash.SIZE));
+  toFr(): Fr {
+    return new Fr(this.toBigInt());
   }
 
-  static override fromString(str: string): BlockHash {
-    return new BlockHash(super.fromString(str).toBuffer());
+  /** Type guard that checks if a value is a BlockHash instance. */
+  static isBlockHash(value: unknown): value is BlockHash {
+    return value instanceof BlockHash;
   }
 
-  static get schema() {
-    return schemas.BufferHex.transform(value => new BlockHash(value));
+  static random() {
+    return new BlockHash(Fr.random());
   }
 
-  static zero() {
-    return new BlockHash(Buffer32.ZERO.toBuffer());
+  static fromBuffer(buffer: Buffer | BufferReader): BlockHash {
+    return new BlockHash(Fr.fromBuffer(buffer));
   }
 
-  static override fromField(hash: Fr) {
-    return new BlockHash(hash.toBuffer());
+  static fromString(str: string): BlockHash {
+    return new BlockHash(Fr.fromString(str));
   }
 
-  toField(): Fr {
-    return Fr.fromBuffer(this.toBuffer());
+  static get schema() {
+    return hexSchemaFor(BlockHash) as ZodFor<BlockHash>;
   }
 }
+
+/** The block header hash for the genesis block (block 0). */
+export const GENESIS_BLOCK_HEADER_HASH: BlockHash = new BlockHash(GENESIS_BLOCK_HEADER_HASH_FR);

package/src/block/block_parameter.ts

@@ -1,10 +1,78 @@
-import { BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { type BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
 import { BlockHash } from './block_hash.js';
 
-export const BlockParameterSchema = z.union([BlockHash.schema, BlockNumberSchema, z.literal('latest')]);
+export const BlockTag = ['latest', 'proposed', 'checkpointed', 'proven', 'finalized'] as const;
 
-/** Block parameter - either a specific BlockNumber, block hash (BlockHash), or 'latest' */
-export type BlockParameter = z.infer<typeof BlockParameterSchema>;
+/**
+ * Tag identifying a block by its position in the chain rather than by an absolute identifier.
+ * - `latest` / `proposed`: Latest L2 block proposed (not necessarily checkpointed/proven yet).
+ * - `checkpointed`: Latest L2 block whose enclosing checkpoint has been published on L1.
+ * - `proven`: Latest L2 block whose enclosing checkpoint has been proven on L1.
+ * - `finalized`: Latest L2 block whose proving L1 transaction has reached L1 finality.
+ */
+export type BlockTag = (typeof BlockTag)[number];
+
+export const BlockTagWithoutLatestSchema = z.union([
+  z.literal('proposed'),
+  z.literal('checkpointed'),
+  z.literal('proven'),
+  z.literal('finalized'),
+]);
+
+export const BlockTagSchema: z.ZodType<BlockTag> = z.union([z.literal('latest'), BlockTagWithoutLatestSchema]);
+
+/**
+ * Object-only form of {@link BlockParameter}. Used as the building block for {@link BlockQuery}.
+ */
+export type NormalizedBlockParameter =
+  | { number: BlockNumber }
+  | { hash: BlockHash }
+  | { archive: Fr }
+  | { tag: Exclude<BlockTag, 'latest'> };
+
+export const NormalizedBlockParameterSchema: z.ZodType<NormalizedBlockParameter, unknown> = z.union([
+  z.object({ number: BlockNumberSchema }).strict(),
+  z.object({ hash: BlockHash.schema }).strict(),
+  z.object({ archive: schemas.Fr }).strict(),
+  z.object({ tag: BlockTagWithoutLatestSchema }).strict(),
+]);
+
+/**
+ * Selector for a block in RPC calls.
+ *
+ * Accepts a block number, a {@link BlockHash}, a chain-tip name (e.g. `'proven'`, `'checkpointed'`),
+ * `'latest'` (alias for `'proposed'`), or any of the {@link NormalizedBlockParameter} object variants
+ * (`{ number }`, `{ hash }`, `{ archive }`, `{ tag }`).
+ */
+export type BlockParameter = NormalizedBlockParameter | BlockNumber | BlockHash | BlockTag;
+
+export const BlockParameterSchema: z.ZodType<BlockParameter, unknown> = z.union([
+  NormalizedBlockParameterSchema,
+  BlockHash.schema,
+  BlockTagSchema,
+  BlockNumberSchema,
+]);
+
+export function inspectBlockParameter(param: BlockParameter) {
+  if (typeof param === 'number') {
+    return param.toString();
+  } else if (typeof param === 'string') {
+    return param;
+  } else if ('number' in param) {
+    return `number=${param.number.toString()}`;
+  } else if ('hash' in param) {
+    return `hash=${param.hash.toString()}`;
+  } else if ('archive' in param) {
+    return `archive=${param.archive.toString()}`;
+  } else if ('tag' in param) {
+    return `tag=${param.tag}`;
+  } else {
+    return jsonStringify(param);
+  }
+}

package/src/block/in_block.ts

@@ -17,7 +17,7 @@ export type DataInBlock<T> = {
 
 export function randomInBlock(): InBlock {
   return {
-    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000)),
+    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000) + 1),
     l2BlockHash: BlockHash.random(),
   };
 }
@@ -33,7 +33,7 @@ export async function wrapDataInBlock<T>(data: T, block: L2Block): Promise<DataI
   return {
     data,
     l2BlockNumber: block.number,
-    l2BlockHash: BlockHash.fromField(await block.hash()),
+    l2BlockHash: await block.hash(),
   };
 }
 

package/src/block/index.ts

@@ -1,3 +1,4 @@
+export * from './block_data.js';
 export * from './l2_block.js';
 export * from './l2_block_stream/index.js';
 export * from './in_block.js';
@@ -5,7 +6,6 @@ export * from './body.js';
 export * from './block_parameter.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
-export * from './checkpointed_l2_block.js';
 export * from './proposal/index.js';
 export * from './validate_block_result.js';
 export * from './l2_block_info.js';

package/src/block/l2_block.ts

@@ -1,4 +1,5 @@
 import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { DA_GAS_PER_FIELD } from '@aztec/constants';
 import {
   BlockNumber,
   CheckpointNumber,
@@ -15,6 +16,7 @@ import { z } from 'zod';
 import type { PrivateLog } from '../logs/private_log.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
+import type { BlockHash } from './block_hash.js';
 import { Body } from './body.js';
 import type { L2BlockInfo } from './l2_block_info.js';
 
@@ -89,9 +91,8 @@ export class L2Block {
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */
-  public async hash(): Promise<Fr> {
-    const blockHash = await this.header.hash();
-    return blockHash.toField();
+  public hash(): Promise<BlockHash> {
+    return this.header.hash();
   }
 
   /**
@@ -175,7 +176,7 @@ export class L2Block {
     } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
   ): Promise<L2Block> {
     const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
-    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
+    const header = BlockHeader.random({ ...blockHeaderOverrides, blockNumber });
     const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
     return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
@@ -221,4 +222,15 @@ export class L2Block {
       timestamp: this.header.globalVariables.timestamp,
     };
   }
+
+  /**
+   * Compute how much DA gas this block uses.
+   *
+   * @remarks This assumes DA gas is computed solely based on the number of blob fields in transactions.
+   * This may change in the future, but we cannot access the actual DA gas used in a block since it's not exposed
+   * in the L2BlockHeader, so we have to rely on recomputing it.
+   */
+  computeDAGasUsed(): number {
+    return this.body.txEffects.reduce((total, txEffect) => total + txEffect.getNumBlobFields(), 0) * DA_GAS_PER_FIELD;
+  }
 }

package/src/block/l2_block_info.ts

@@ -5,8 +5,10 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
+import { BlockHash } from './block_hash.js';
+
 export type L2BlockInfo = {
-  blockHash?: Fr;
+  blockHash?: BlockHash;
   archive: Fr;
   lastArchive: Fr;
   blockNumber: BlockNumber;
@@ -17,7 +19,7 @@ export type L2BlockInfo = {
 
 export function randomBlockInfo(blockNumber?: BlockNumber | number): L2BlockInfo {
   return {
-    blockHash: Fr.random(),
+    blockHash: BlockHash.random(),
     archive: Fr.random(),
     lastArchive: Fr.random(),
     blockNumber: BlockNumber(blockNumber ?? Math.floor(Math.random() * 100000) + 1),
@@ -28,7 +30,7 @@ export function randomBlockInfo(blockNumber?: BlockNumber | number): L2BlockInfo
 }
 
 export const BlockInfoSchema = z.object({
-  blockHash: schemas.Fr.optional(),
+  blockHash: BlockHash.schema.optional(),
   archive: schemas.Fr,
   lastArchive: schemas.Fr,
   blockNumber: BlockNumberSchema,
@@ -39,7 +41,7 @@ export const BlockInfoSchema = z.object({
 
 export function serializeBlockInfo(blockInfo: L2BlockInfo): Buffer {
   return serializeToBuffer(
-    blockInfo.blockHash ?? Fr.ZERO,
+    blockInfo.blockHash ?? BlockHash.ZERO,
     blockInfo.archive,
     blockInfo.lastArchive,
     blockInfo.blockNumber,
@@ -51,9 +53,9 @@ export function serializeBlockInfo(blockInfo: L2BlockInfo): Buffer {
 
 export function deserializeBlockInfo(buffer: Buffer | BufferReader): L2BlockInfo {
   const reader = BufferReader.asReader(buffer);
-  const blockHash = reader.readObject(Fr);
+  const blockHash = BlockHash.fromBuffer(reader);
   return {
-    blockHash: blockHash.equals(Fr.ZERO) ? undefined : blockHash,
+    blockHash: blockHash.equals(BlockHash.ZERO) ? undefined : blockHash,
     archive: reader.readObject(Fr),
     lastArchive: reader.readObject(Fr),
     blockNumber: BlockNumber(reader.readNumber()),