@aztec/stdlib 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

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/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),
     );
   }
@@ -1147,7 +1152,7 @@ export class CallStackMetadata {
 
     const { stack, leaf } = failingCall;
     const aztecCallStack = stack.map(call => ({
-      contractAddress: AztecAddress.fromField(call.contractAddress),
+      contractAddress: AztecAddress.fromFieldUnsafe(call.contractAddress),
       functionSelector: call.calldata.length > 0 ? FunctionSelector.fromFieldOrUndefined(call.calldata[0]) : undefined,
     }));
 

package/src/avm/avm_accumulated_data.ts

@@ -88,11 +88,11 @@ export class AvmAccumulatedData {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new this(
-      reader.readTuple(MAX_NOTE_HASHES_PER_TX, Fr),
-      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
-      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
       reader.readObject(FlatPublicLogs),
-      reader.readTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
+      reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
 
@@ -115,9 +115,9 @@ export class AvmAccumulatedData {
     return new this(
       reader.readFieldArray(MAX_NOTE_HASHES_PER_TX),
       reader.readFieldArray(MAX_NULLIFIERS_PER_TX),
-      reader.readTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
+      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
       reader.readObject(FlatPublicLogs),
-      reader.readTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
+      reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
 

package/src/avm/avm_circuit_public_inputs.ts

@@ -143,8 +143,8 @@ export class AvmCircuitPublicInputs {
       reader.readObject(AztecAddress),
       reader.readObject(Fr),
       reader.readObject(PublicCallRequestArrayLengths),
-      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
-      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readObject(PublicCallRequest),
       reader.readObject(PrivateToAvmAccumulatedDataArrayLengths),
       reader.readObject(PrivateToAvmAccumulatedDataArrayLengths),
@@ -206,8 +206,8 @@ export class AvmCircuitPublicInputs {
       AztecAddress.fromFields(reader),
       reader.readField(),
       PublicCallRequestArrayLengths.fromFields(reader),
-      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
-      reader.readTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
+      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       PublicCallRequest.fromFields(reader),
       PrivateToAvmAccumulatedDataArrayLengths.fromFields(reader),
       PrivateToAvmAccumulatedDataArrayLengths.fromFields(reader),

package/src/avm/index.ts

@@ -3,10 +3,5 @@ export * from './avm_accumulated_data.js';
 export * from './avm_circuit_public_inputs.js';
 export * from './revert_code.js';
 export * from './public_data_write.js';
-export * from './public_data_update_request.js';
-export * from './contract_storage_update_request.js';
-export * from './contract_storage_read.js';
-export * from './public_inner_call_request.js';
-export * from './public_call_stack_item_compressed.js';
 export * from './avm_proving_request.js';
 export * from './message_pack.js';

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

@@ -28,12 +28,6 @@ export class RevertCode {
   }
   static readonly OK: RevertCode = new RevertCode(RevertCodeEnum.OK);
   static readonly REVERTED: RevertCode = new RevertCode(RevertCodeEnum.REVERTED);
-  /** @deprecated Use REVERTED instead. */
-  static readonly APP_LOGIC_REVERTED: RevertCode = RevertCode.REVERTED;
-  /** @deprecated Use REVERTED instead. */
-  static readonly TEARDOWN_REVERTED: RevertCode = RevertCode.REVERTED;
-  /** @deprecated Use REVERTED instead. */
-  static readonly BOTH_REVERTED: RevertCode = RevertCode.REVERTED;
 
   public getCode(): RevertCodeEnum {
     return this.code;

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,32 +42,65 @@ 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.fromBigIntUnsafe(NULL_MSG_SENDER_CONTRACT_ADDRESS);
+
   static zero(): AztecAddress {
     return AztecAddress.ZERO;
   }
 
-  static fromField(fr: Fr) {
+  /**
+   * Builds an `AztecAddress` from a field **without checking it is a valid address** (the x-coordinate of a point on
+   * the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to validate an
+   * untrusted one, or {@link AztecAddress.random} for valid test addresses.
+   */
+  static fromFieldUnsafe(fr: Fr) {
     return new AztecAddress(fr);
   }
 
+  /**
+   * Deserializes an `AztecAddress` from a buffer. It does **not** check the value is a valid Grumpkin-curve address
+   * (see {@link AztecAddress.isValid}); it is meant for reading addresses from already-validated serialized data. Use
+   * {@link AztecAddress.random} for valid test addresses.
+   */
   static fromBuffer(buffer: Buffer | BufferReader) {
     return new AztecAddress(fromBuffer(buffer, Fr));
   }
 
+  /**
+   * Deserializes an `AztecAddress` from a field reader. It does **not** check the value is a valid Grumpkin-curve
+   * address (see {@link AztecAddress.isValid}); it is meant for reading addresses from already-validated serialized
+   * data. Use {@link AztecAddress.random} for valid test addresses.
+   */
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
     return new AztecAddress(reader.readField());
   }
 
-  static fromBigInt(value: bigint) {
+  /**
+   * Builds an `AztecAddress` from a bigint **without checking it is a valid address** (the x-coordinate of a point on
+   * the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to validate an
+   * untrusted one, or {@link AztecAddress.random} for valid test addresses.
+   */
+  static fromBigIntUnsafe(value: bigint) {
     return new AztecAddress(new Fr(value));
   }
 
-  static fromNumber(value: number) {
+  /**
+   * Builds an `AztecAddress` from a number **without checking it is a valid address** (the x-coordinate of a point on
+   * the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to validate an
+   * untrusted one, or {@link AztecAddress.random} for valid test addresses.
+   */
+  static fromNumberUnsafe(value: number) {
     return new AztecAddress(new Fr(value));
   }
 
-  static fromString(buf: string) {
+  /**
+   * Builds an `AztecAddress` from a hex string **without checking it is a valid address** (the x-coordinate of a
+   * point on the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to
+   * validate an untrusted one, or {@link AztecAddress.random} for valid test addresses.
+   */
+  static fromStringUnsafe(buf: string) {
     return new AztecAddress(hexToBuffer(buf));
   }
 
@@ -88,7 +119,7 @@ export class AztecAddress {
     if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
       return new AztecAddress(obj);
     }
-    return AztecAddress.fromString(obj);
+    return AztecAddress.fromStringUnsafe(obj);
   }
 
   /**
@@ -136,8 +167,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 +201,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
@@ -60,7 +60,12 @@ export function getAttestationInfoFromPayload(
       return { address: attestation.address, status: 'provided-as-address' as const };
     }
 
-    // Try to recover address from signature
+    // Try to recover address from signature. Recover with default opts (no allowYParityAsV): a slot
+    // whose recovery byte is in yParity form (v ∈ {0, 1}) is judged invalid here, matching L1 proving
+    // (ValidatorSelectionLib.verifyAttestations → ECDSA.recover only accepts v ∈ {27, 28}). A malicious
+    // proposer that lands such a slot cannot have it silently treated as valid off-chain; it is routed to
+    // invalid-attestation and invalidated. The gossip receipt path (recoverCoordinationSigner) stays
+    // lenient with allowYParityAsV; A-1351 normalizes on pool ingress and before the L1 bundle.
     try {
       const recoveredAddress = recoverAddress(hashedPayload, attestation.signature);
       return { address: recoveredAddress, status: 'recovered-from-signature' as const };

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';

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()),