@aztec/stdlib 5.0.0-private.20260319 → 5.0.0-rc.1

package/src/abi/function_signature_decoder.ts

@@ -0,0 +1,77 @@
+import type { ABIParameter, ABIVariable, AbiType } from './abi.js';
+
+/**
+ * Decodes the signature of a function from the name and parameters.
+ */
+export class FunctionSignatureDecoder {
+  private separator: string;
+  constructor(
+    private name: string,
+    private parameters: ABIParameter[],
+    private includeNames = false,
+  ) {
+    this.separator = includeNames ? ', ' : ',';
+  }
+
+  /**
+   * Decodes a single function parameter type for the function signature.
+   * @param param - The parameter type to decode.
+   * @returns A string representing the parameter type.
+   */
+  private getParameterType(param: AbiType): string {
+    switch (param.kind) {
+      case 'field':
+        return 'Field';
+      case 'integer':
+        return param.sign === 'signed' ? `i${param.width}` : `u${param.width}`;
+      case 'boolean':
+        return 'bool';
+      case 'array':
+        return `[${this.getParameterType(param.type)};${param.length}]`;
+      case 'string':
+        return `str<${param.length}>`;
+      case 'struct':
+        return `(${param.fields.map(field => `${this.decodeParameter(field)}`).join(this.separator)})`;
+      default:
+        throw new Error(`Unsupported type: ${param.kind}`);
+    }
+  }
+
+  /**
+   * Decodes a single function parameter for the function signature.
+   * @param param - The parameter to decode.
+   * @returns A string representing the parameter type and optionally its name.
+   */
+  private decodeParameter(param: ABIVariable): string {
+    const type = this.getParameterType(param.type);
+    return this.includeNames ? `${param.name}: ${type}` : type;
+  }
+
+  /**
+   * Decodes all the parameters and build the function signature
+   * @returns The function signature.
+   */
+  public decode(): string {
+    return `${this.name}(${this.parameters.map(param => this.decodeParameter(param)).join(this.separator)})`;
+  }
+}
+
+/**
+ * Decodes a function signature from the name and parameters.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The function signature.
+ */
+export function decodeFunctionSignature(name: string, parameters: ABIParameter[]) {
+  return new FunctionSignatureDecoder(name, parameters).decode();
+}
+
+/**
+ * Decodes a function signature from the name and parameters including parameter names.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The user-friendly function signature.
+ */
+export function decodeFunctionSignatureWithParameterNames(name: string, parameters: ABIParameter[]) {
+  return new FunctionSignatureDecoder(name, parameters, true).decode();
+}

package/src/abi/index.ts

@@ -1,6 +1,7 @@
 export * from './abi.js';
 export * from './buffer.js';
 export * from './decoder.js';
+export * from './function_signature_decoder.js';
 export * from './encoder.js';
 export * from './authorization_selector.js';
 export * from './event_metadata_definition.js';

package/src/abi/note_selector.ts

@@ -2,23 +2,17 @@ import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, TypeRegistry } from '@aztec/foundation/serialize';
+import { BufferReader } from '@aztec/foundation/serialize';
 
 import { Selector } from './selector.js';
 
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Note selector branding */
-export interface NoteSelector {
-  /** Brand. */
-  _branding: 'NoteSelector';
-}
-
 /**
  * A note selector is a 7 bit long value that identifies a note type within a contract.
  * TODO(#10952): Encoding of note type id can be reduced to 7 bits.
  */
 export class NoteSelector extends Selector {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'NoteSelector';
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer  or BufferReader to read from.
@@ -73,6 +67,3 @@ export class NoteSelector extends Selector {
     return hexSchemaFor(NoteSelector);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('NoteSelector', NoteSelector);

package/src/abi/selector.ts

@@ -4,7 +4,7 @@ import { bufferToHex } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
-/** A selector is the first 4 bytes of the hash of a signature. */
+/** A selector is the low 4 bytes of the poseidon2 hash of a signature. */
 export abstract class Selector {
   /** The size of the selector in bytes. */
   public static SIZE = 4;

package/src/abi/utils.ts

@@ -58,11 +58,13 @@ export function isPublicKeysStruct(abiType: AbiType) {
   return (
     abiType.kind === 'struct' &&
     abiType.path === 'aztec::protocol_types::public_keys::PublicKeys' &&
-    abiType.fields.length === 4 &&
-    abiType.fields[0].name === 'npk_m' &&
+    abiType.fields.length === 6 &&
+    abiType.fields[0].name === 'npk_m_hash' &&
     abiType.fields[1].name === 'ivpk_m' &&
-    abiType.fields[2].name === 'ovpk_m' &&
-    abiType.fields[3].name === 'tpk_m'
+    abiType.fields[2].name === 'ovpk_m_hash' &&
+    abiType.fields[3].name === 'tpk_m_hash' &&
+    abiType.fields[4].name === 'mspk_m_hash' &&
+    abiType.fields[5].name === 'fbpk_m_hash'
   );
 }
 

package/src/avm/avm.ts

@@ -130,6 +130,7 @@ export class AvmContractInstanceHint {
     public readonly currentContractClassId: Fr,
     public readonly originalContractClassId: Fr,
     public readonly initializationHash: Fr,
+    public readonly immutablesHash: Fr,
     public readonly publicKeys: PublicKeys,
   ) {}
 
@@ -143,6 +144,7 @@ export class AvmContractInstanceHint {
         currentContractClassId: schemas.Fr,
         originalContractClassId: schemas.Fr,
         initializationHash: schemas.Fr,
+        immutablesHash: schemas.Fr,
         publicKeys: PublicKeys.schema,
       })
       .transform(
@@ -154,6 +156,7 @@ export class AvmContractInstanceHint {
           currentContractClassId,
           originalContractClassId,
           initializationHash,
+          immutablesHash,
           publicKeys,
         }) =>
           new AvmContractInstanceHint(
@@ -164,6 +167,7 @@ export class AvmContractInstanceHint {
             currentContractClassId,
             originalContractClassId,
             initializationHash,
+            immutablesHash,
             publicKeys,
           ),
       );
@@ -188,6 +192,7 @@ export class AvmContractInstanceHint {
       Fr.fromPlainObject(obj.currentContractClassId),
       Fr.fromPlainObject(obj.originalContractClassId),
       Fr.fromPlainObject(obj.initializationHash),
+      Fr.fromPlainObject(obj.immutablesHash),
       PublicKeys.fromPlainObject(obj.publicKeys),
     );
   }

package/src/avm/message_pack.ts

@@ -64,13 +64,22 @@ function setUpMessagePackExtensions() {
   addExtension({
     Class: Point,
     write: (p: Point) => {
-      assert(!p.inf, 'Cannot serialize infinity');
-      // TODO: should these be Frs?
+      // TODO: Now that we use a 2 elt point representation, we should be able to handle infs here.
+      // However this opens possible bad paths with public keys and requires sanitised conversion between
+      // BB's inf representation (see below), and ours/Noir's (0, 0), and empty points from BB, when inf
+      // does not actually pass through.
+      assert(!p.isInfinite, 'Cannot serialize infinity');
       return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
     },
     read: (data: { x: Fq; y: Fq }) => {
+      // Note: BB encodes infinity as x == y == Buffer of all ones.
+      // Infinity should never pass through here, but for correctness:
+      const ALL_ONES = (1n << 256n) - 1n;
+      if (data.x.toBigInt() === ALL_ONES && data.y.toBigInt() === ALL_ONES) {
+        return Point.INFINITY;
+      }
       // Convert Fq back to Fr for Point constructor
-      return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()), false);
+      return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()));
     },
   });
   // EthAddress is a class that has a buffer in TS, but is itself just a field in C++.

package/src/avm/revert_code.ts

@@ -5,35 +5,17 @@ import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 
-/**
- * Tracks which revertible phases of a transaction's public execution reverted.
- *
- * A transaction executes in three sequential phases:
- *   1. SETUP     – non-revertible; if this fails the entire transaction is rejected.
- *   2. APP_LOGIC – revertible; its state changes are rolled back on failure.
- *   3. TEARDOWN  – revertible; always runs (even after app-logic revert) so the fee-payment contract can clean up.
- *
- * Only APP_LOGIC and TEARDOWN can produce a revert code. SETUP failures throw instead and discard the transaction
- * entirely.
- */
+/** Whether a transaction's public execution reverted. */
 export enum RevertCodeEnum {
   /** All phases completed successfully; no state was rolled back. */
   OK = 0,
-  /** APP_LOGIC reverted; its state changes were discarded. If present, TEARDOWN still ran and succeeded. */
-  APP_LOGIC_REVERTED = 1,
-  /** TEARDOWN reverted; its state changes were discarded. APP_LOGIC succeeded. */
-  TEARDOWN_REVERTED = 2,
-  /** Both APP_LOGIC and TEARDOWN reverted; only SETUP effects are kept. */
-  BOTH_REVERTED = 3,
+  /** One or more revertible phases reverted; their state changes were discarded. */
+  REVERTED = 1,
 }
 
-function isRevertCodeEnum(value: number): value is RevertCodeEnum {
-  return (
-    (value as RevertCodeEnum) === RevertCodeEnum.OK ||
-    (value as RevertCodeEnum) === RevertCodeEnum.APP_LOGIC_REVERTED ||
-    (value as RevertCodeEnum) === RevertCodeEnum.TEARDOWN_REVERTED ||
-    (value as RevertCodeEnum) === RevertCodeEnum.BOTH_REVERTED
-  );
+/** Returns a valid RevertCodeEnum, coercing any value >= 1 to REVERTED. */
+function toRevertCodeEnum(value: number): RevertCodeEnum {
+  return value >= 1 ? RevertCodeEnum.REVERTED : RevertCodeEnum.OK;
 }
 
 /**
@@ -45,9 +27,7 @@ export class RevertCode {
     this.code = e.valueOf();
   }
   static readonly OK: RevertCode = new RevertCode(RevertCodeEnum.OK);
-  static readonly APP_LOGIC_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.APP_LOGIC_REVERTED);
-  static readonly TEARDOWN_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.TEARDOWN_REVERTED);
-  static readonly BOTH_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.BOTH_REVERTED);
+  static readonly REVERTED: RevertCode = new RevertCode(RevertCodeEnum.REVERTED);
 
   public getCode(): RevertCodeEnum {
     return this.code;
@@ -65,12 +45,8 @@ export class RevertCode {
     switch (this.code as RevertCodeEnum) {
       case RevertCodeEnum.OK:
         return 'OK';
-      case RevertCodeEnum.APP_LOGIC_REVERTED:
-        return 'Application logic reverted';
-      case RevertCodeEnum.TEARDOWN_REVERTED:
-        return 'Teardown reverted';
-      case RevertCodeEnum.BOTH_REVERTED:
-        return 'Both reverted';
+      case RevertCodeEnum.REVERTED:
+        return 'Reverted';
       default:
         return `Unknown RevertCode: ${this.code}`;
     }
@@ -81,7 +57,11 @@ export class RevertCode {
   }
 
   static get schema(): ZodFor<RevertCode> {
-    return z.nativeEnum(RevertCodeEnum).transform(value => new RevertCode(value));
+    return z
+      .number()
+      .int()
+      .min(0)
+      .transform(value => new RevertCode(toRevertCodeEnum(value)));
   }
 
   /**
@@ -96,10 +76,10 @@ export class RevertCode {
       return obj;
     }
     const code = typeof obj === 'number' ? obj : (obj.code ?? obj);
-    if (!isRevertCodeEnum(code)) {
+    if (typeof code !== 'number' || code < 0) {
       throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(code);
+    return new RevertCode(toRevertCodeEnum(code));
   }
 
   /**
@@ -131,10 +111,10 @@ export class RevertCode {
   }
 
   public static fromNumber(code: number): RevertCode {
-    if (!isRevertCodeEnum(code)) {
+    if (code < 0) {
       throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(code);
+    return new RevertCode(toRevertCodeEnum(code));
   }
 
   public static fromField(field: Fr): RevertCode {
@@ -152,7 +132,7 @@ export class RevertCode {
     return RevertCode.fromNumber(code);
   }
 
-  private static readonly NUM_OPTIONS = 4;
+  private static readonly NUM_OPTIONS = 2;
   static random(): RevertCode {
     return new RevertCode(Math.floor(Math.random() * RevertCode.NUM_OPTIONS));
   }

package/src/aztec-address/index.ts

@@ -1,18 +1,13 @@
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+import { NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
 import { Fr, fromBuffer } from '@aztec/foundation/curves/bn254';
 import { Point } from '@aztec/foundation/curves/grumpkin';
 import { type ZodFor, bufferSchemaFor, hexSchemaFor } from '@aztec/foundation/schemas';
-import { type BufferReader, FieldReader, TypeRegistry } from '@aztec/foundation/serialize';
+import { type BufferReader, type BufferSink, FieldReader } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
-/** Branding to ensure fields are not interchangeable types. */
-export interface AztecAddress {
-  /** Brand. */
-  _branding: 'AztecAddress';
-}
 /**
  * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
  * compare addresses, as well as conversion to and from strings, buffers, and other formats.
@@ -23,6 +18,9 @@ export interface AztecAddress {
  * wild.
  */
 export class AztecAddress {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'AztecAddress';
+
   private xCoord: Fr;
 
   constructor(buffer: Buffer | Fr) {
@@ -44,6 +42,9 @@ export class AztecAddress {
 
   static ZERO = new AztecAddress(Buffer.alloc(32, 0));
 
+  /** Null msg sender address. Not part of the protocol contracts tree. */
+  static NULL_MSG_SENDER = AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS);
+
   static zero(): AztecAddress {
     return AztecAddress.ZERO;
   }
@@ -136,8 +137,13 @@ export class AztecAddress {
     return Point.fromXAndSign(this.xCoord, true);
   }
 
-  toBuffer() {
-    return this.xCoord.toBuffer();
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return this.xCoord.toBuffer();
+    }
+    this.xCoord.toBuffer(sink);
   }
 
   toBigInt() {
@@ -165,6 +171,3 @@ export class AztecAddress {
     ]);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('AztecAddress', AztecAddress);

package/src/block/attestation_info.ts

@@ -3,7 +3,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 
 import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
-import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
+import { type CoordinationSignatureContext, getHashedSignaturePayloadTypedData } from '../p2p/signature_utils.js';
 import type { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
@@ -32,11 +32,14 @@ export type AttestationInfo =
  * Extracts attestation information from a published checkpoint.
  * Returns info for each attestation, preserving array indices.
  */
-export function getAttestationInfoFromPublishedCheckpoint(block: {
-  attestations: CommitteeAttestation[];
-  checkpoint: Checkpoint;
-}): AttestationInfo[] {
-  const payload = ConsensusPayload.fromCheckpoint(block.checkpoint);
+export function getAttestationInfoFromPublishedCheckpoint(
+  block: {
+    attestations: CommitteeAttestation[];
+    checkpoint: Checkpoint;
+  },
+  signatureContext: CoordinationSignatureContext,
+): AttestationInfo[] {
+  const payload = ConsensusPayload.fromCheckpoint(block.checkpoint, signatureContext);
   return getAttestationInfoFromPayload(payload, block.attestations);
 }
 
@@ -44,10 +47,7 @@ export function getAttestationInfoFromPayload(
   payload: ConsensusPayload,
   attestations: CommitteeAttestation[],
 ): AttestationInfo[] {
-  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(
-    payload,
-    SignatureDomainSeparator.checkpointAttestation,
-  );
+  const hashedPayload = getHashedSignaturePayloadTypedData(payload);
 
   return attestations.map(attestation => {
     // If signature is empty, check if we have an address directly
@@ -62,7 +62,7 @@ export function getAttestationInfoFromPayload(
 
     // Try to recover address from signature
     try {
-      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature);
+      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature, { allowYParityAsV: true });
       return { address: recoveredAddress, status: 'recovered-from-signature' as const };
     } catch {
       // Signature present but recovery failed

package/src/block/block_data.ts

@@ -1,18 +1,17 @@
 import { CheckpointNumberSchema, IndexWithinCheckpointSchema } from '@aztec/foundation/branded-types';
 import type { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import { schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
+import { BlockHash } from './block_hash.js';
 
 /** L2Block metadata. Equivalent to L2Block but without block body containing tx data. */
 export type BlockData = {
   header: BlockHeader;
   archive: AppendOnlyTreeSnapshot;
-  blockHash: Fr;
+  blockHash: BlockHash;
   checkpointNumber: CheckpointNumber;
   indexWithinCheckpoint: IndexWithinCheckpoint;
 };
@@ -20,7 +19,7 @@ export type BlockData = {
 export const BlockDataSchema = z.object({
   header: BlockHeader.schema,
   archive: AppendOnlyTreeSnapshot.schema,
-  blockHash: schemas.Fr,
+  blockHash: BlockHash.schema,
   checkpointNumber: CheckpointNumberSchema,
   indexWithinCheckpoint: IndexWithinCheckpointSchema,
 });

package/src/block/block_hash.ts

@@ -1,21 +1,24 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
+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 { inspect } from 'util';
 
 import { hexSchemaFor } from '../schemas/schemas.js';
 
-const BLOCK_HASH_BRAND = Symbol.for('aztec.BlockHash');
-
 /** Hash of an L2 block. */
-export class BlockHash extends Fr {
-  readonly [BLOCK_HASH_BRAND] = true as const;
+export class BlockHash extends BaseFr {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'BlockHash';
+
+  static ZERO = new BlockHash(Fr.ZERO);
 
   constructor(hash: Fr) {
     super(hash);
   }
 
-  override [inspect.custom]() {
+  [inspect.custom]() {
     return `BlockHash<${this.toString()}>`;
   }
 
@@ -23,23 +26,27 @@ export class BlockHash extends Fr {
     return new Fr(this.toBigInt());
   }
 
-  /**
-   * Type guard that checks if a value is a BlockHash instance.
-   * Uses Symbol.for to ensure cross-module compatibility.
-   */
+  /** Type guard that checks if a value is a BlockHash instance. */
   static isBlockHash(value: unknown): value is BlockHash {
-    return typeof value === 'object' && value !== null && BLOCK_HASH_BRAND in value;
+    return value instanceof BlockHash;
   }
 
-  static override random() {
+  static random() {
     return new BlockHash(Fr.random());
   }
 
-  static override fromString(str: string): BlockHash {
+  static fromBuffer(buffer: Buffer | BufferReader): BlockHash {
+    return new BlockHash(Fr.fromBuffer(buffer));
+  }
+
+  static fromString(str: string): BlockHash {
     return new BlockHash(Fr.fromString(str));
   }
 
-  static override get schema() {
+  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/index.ts

@@ -6,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';