@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b9865e97

package/src/avm/avm_accumulated_data.ts

@@ -7,7 +7,7 @@ import {
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import {
   BufferReader,
@@ -149,6 +149,35 @@ export class AvmAccumulatedData {
     );
   }
 
+  /**
+   * Creates an AvmAccumulatedData instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmAccumulatedData fields
+   * @returns An AvmAccumulatedData instance
+   */
+  static fromPlainObject(obj: any): AvmAccumulatedData {
+    return new AvmAccumulatedData(
+      assertLength(
+        obj.noteHashes.map((h: any) => Fr.fromPlainObject(h)),
+        MAX_NOTE_HASHES_PER_TX,
+      ),
+      assertLength(
+        obj.nullifiers.map((n: any) => Fr.fromPlainObject(n)),
+        MAX_NULLIFIERS_PER_TX,
+      ),
+      assertLength(
+        obj.l2ToL1Msgs.map((m: any) => ScopedL2ToL1Message.fromPlainObject(m)),
+        MAX_L2_TO_L1_MSGS_PER_TX,
+      ),
+      FlatPublicLogs.fromPlainObject(obj.publicLogs),
+      assertLength(
+        obj.publicDataWrites.map((w: any) => PublicDataWrite.fromPlainObject(w)),
+        MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+      ),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.noteHashes.every(x => x.isZero()) &&
@@ -265,6 +294,17 @@ export class AvmAccumulatedDataArrayLengths {
     return new AvmAccumulatedDataArrayLengths(0, 0, 0, 0);
   }
 
+  /**
+   * Creates an AvmAccumulatedDataArrayLengths instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmAccumulatedDataArrayLengths fields
+   * @returns An AvmAccumulatedDataArrayLengths instance
+   */
+  static fromPlainObject(obj: any): AvmAccumulatedDataArrayLengths {
+    return new AvmAccumulatedDataArrayLengths(obj.noteHashes, obj.nullifiers, obj.l2ToL1Msgs, obj.publicDataWrites);
+  }
+
   [inspect.custom]() {
     return `AvmAccumulatedDataArrayLengths {
   noteHashes: ${this.noteHashes},

package/src/avm/avm_circuit_public_inputs.ts

@@ -1,6 +1,6 @@
 import { MAX_ENQUEUED_CALLS_PER_TX } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, type Tuple, assertLength, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -276,6 +276,46 @@ export class AvmCircuitPublicInputs {
     );
   }
 
+  /**
+   * Creates an AvmCircuitPublicInputs instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing AvmCircuitPublicInputs fields
+   * @returns An AvmCircuitPublicInputs instance
+   */
+  static fromPlainObject(obj: any): AvmCircuitPublicInputs {
+    return new AvmCircuitPublicInputs(
+      GlobalVariables.fromPlainObject(obj.globalVariables),
+      ProtocolContracts.fromPlainObject(obj.protocolContracts),
+      TreeSnapshots.fromPlainObject(obj.startTreeSnapshots),
+      Gas.fromPlainObject(obj.startGasUsed),
+      GasSettings.fromPlainObject(obj.gasSettings),
+      GasFees.fromPlainObject(obj.effectiveGasFees),
+      AztecAddress.fromPlainObject(obj.feePayer),
+      Fr.fromPlainObject(obj.proverId),
+      PublicCallRequestArrayLengths.fromPlainObject(obj.publicCallRequestArrayLengths),
+      assertLength(
+        obj.publicSetupCallRequests.map((r: any) => PublicCallRequest.fromPlainObject(r)),
+        MAX_ENQUEUED_CALLS_PER_TX,
+      ),
+      assertLength(
+        obj.publicAppLogicCallRequests.map((r: any) => PublicCallRequest.fromPlainObject(r)),
+        MAX_ENQUEUED_CALLS_PER_TX,
+      ),
+      PublicCallRequest.fromPlainObject(obj.publicTeardownCallRequest),
+      PrivateToAvmAccumulatedDataArrayLengths.fromPlainObject(obj.previousNonRevertibleAccumulatedDataArrayLengths),
+      PrivateToAvmAccumulatedDataArrayLengths.fromPlainObject(obj.previousRevertibleAccumulatedDataArrayLengths),
+      PrivateToAvmAccumulatedData.fromPlainObject(obj.previousNonRevertibleAccumulatedData),
+      PrivateToAvmAccumulatedData.fromPlainObject(obj.previousRevertibleAccumulatedData),
+      TreeSnapshots.fromPlainObject(obj.endTreeSnapshots),
+      Gas.fromPlainObject(obj.endGasUsed),
+      AvmAccumulatedDataArrayLengths.fromPlainObject(obj.accumulatedDataArrayLengths),
+      AvmAccumulatedData.fromPlainObject(obj.accumulatedData),
+      Fr.fromPlainObject(obj.transactionFee),
+      obj.reverted,
+    );
+  }
+
   public serializeWithMessagePack(): Buffer {
     return serializeWithMessagePack(this);
   }

package/src/avm/contract_storage_read.ts

@@ -1,5 +1,5 @@
 import { CONTRACT_STORAGE_READ_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { AztecAddress } from '../aztec-address/index.js';

package/src/avm/contract_storage_update_request.ts

@@ -1,5 +1,5 @@
 import { CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/avm/message_pack.ts

@@ -1,5 +1,6 @@
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fq, Fr, Point } from '@aztec/foundation/fields';
 
 import { strict as assert } from 'assert';
 import { Decoder, Encoder, addExtension } from 'msgpackr';
@@ -18,7 +19,10 @@ export function serializeWithMessagePack(obj: any): Buffer {
   return encoder.encode(obj);
 }
 
-export function deserializeFromMessagePack<T>(buffer: Buffer): T {
+// This deserializes into a JS object. If you want a specific
+// class, you need to use zod to parse it into the specific class.
+// You can use T.schema.parse() for that.
+export function deserializeFromMessagePack(buffer: Buffer): any {
   setUpMessagePackExtensions();
   const decoder = new Decoder({
     useRecords: false,
@@ -60,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/public_call_stack_item_compressed.ts

@@ -1,5 +1,5 @@
 import { PUBLIC_CALL_STACK_ITEM_COMPRESSED_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/avm/public_data_read.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**

package/src/avm/public_data_update_request.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';

package/src/avm/public_data_write.ts

@@ -1,5 +1,5 @@
 import { PUBLIC_DATA_WRITE_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -61,7 +61,7 @@ export class PublicDataWrite {
     return new PublicDataWrite(reader.readField(), reader.readField());
   }
 
-  toBlobFields(): Fr[] {
+  toBlobFields(): [Fr, Fr] {
     return [this.leafSlot, this.value];
   }
 
@@ -86,6 +86,17 @@ export class PublicDataWrite {
     return new PublicDataWrite(Fr.ZERO, Fr.ZERO);
   }
 
+  /**
+   * Creates a PublicDataWrite instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataWrite fields
+   * @returns A PublicDataWrite instance
+   */
+  static fromPlainObject(obj: any): PublicDataWrite {
+    return new PublicDataWrite(Fr.fromPlainObject(obj.leafSlot), Fr.fromPlainObject(obj.value));
+  }
+
   static random() {
     return new PublicDataWrite(Fr.random(), Fr.random());
   }

package/src/avm/public_inner_call_request.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/avm/revert_code.ts

@@ -1,23 +1,21 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
+/** Whether a transaction's public execution reverted. */
 export enum RevertCodeEnum {
+  /** All phases completed successfully; no state was rolled back. */
   OK = 0,
-  APP_LOGIC_REVERTED = 1,
-  TEARDOWN_REVERTED = 2,
-  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;
 }
 
 /**
@@ -29,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;
@@ -49,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}`;
     }
@@ -64,8 +56,30 @@ export class RevertCode {
     return this.code;
   }
 
-  static get schema() {
-    return z.nativeEnum(RevertCodeEnum).transform(value => new RevertCode(value));
+  static get schema(): ZodFor<RevertCode> {
+    return z
+      .number()
+      .int()
+      .min(0)
+      .transform(value => new RevertCode(toRevertCodeEnum(value)));
+  }
+
+  /**
+   * Creates a RevertCode from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object, number, or RevertCode instance
+   * @returns A RevertCode instance
+   */
+  static fromPlainObject(obj: any): RevertCode {
+    if (obj instanceof RevertCode) {
+      return obj;
+    }
+    const code = typeof obj === 'number' ? obj : (obj.code ?? obj);
+    if (typeof code !== 'number' || code < 0) {
+      throw new Error(`Invalid RevertCode: ${code}`);
+    }
+    return new RevertCode(toRevertCodeEnum(code));
   }
 
   /**
@@ -96,11 +110,15 @@ export class RevertCode {
     return this.toBuffer().length;
   }
 
-  public static fromField(fr: Fr): RevertCode {
-    if (!isRevertCodeEnum(fr.toNumber())) {
-      throw new Error(`Invalid RevertCode: ${fr.toNumber()}`);
+  public static fromNumber(code: number): RevertCode {
+    if (code < 0) {
+      throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(fr.toNumber());
+    return new RevertCode(toRevertCodeEnum(code));
+  }
+
+  public static fromField(field: Fr): RevertCode {
+    return RevertCode.fromNumber(field.toNumber());
   }
 
   public static fromFields(fields: Fr[] | FieldReader): RevertCode {
@@ -111,13 +129,10 @@ export class RevertCode {
   public static fromBuffer(buffer: Buffer | BufferReader): RevertCode {
     const reader = BufferReader.asReader(buffer);
     const code = reader.readBytes(RevertCode.PACKED_SIZE_IN_BYTES).readUInt8(0);
-    if (!isRevertCodeEnum(code)) {
-      throw new Error(`Invalid RevertCode: ${code}`);
-    }
-    return new RevertCode(code);
+    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,16 +1,13 @@
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-import { Fr, Point, fromBuffer } from '@aztec/foundation/fields';
-import { type ZodFor, hexSchemaFor } from '@aztec/foundation/schemas';
-import { type BufferReader, FieldReader, TypeRegistry } from '@aztec/foundation/serialize';
+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, 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.
@@ -21,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) {
@@ -42,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;
   }
@@ -71,6 +74,24 @@ export class AztecAddress {
     return new AztecAddress(hexToBuffer(buf));
   }
 
+  /**
+   * Creates an AztecAddress from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * Handles buffers, strings, or existing instances.
+   * @param obj - Plain object, buffer, string, or AztecAddress instance
+   * @returns An AztecAddress instance
+   */
+  static fromPlainObject(obj: any): AztecAddress {
+    if (obj instanceof AztecAddress) {
+      return obj;
+    }
+    if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
+      return new AztecAddress(obj);
+    }
+    return AztecAddress.fromString(obj);
+  }
+
   /**
    * @returns a random valid address (i.e. one that can be encrypted to).
    */
@@ -116,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() {
@@ -137,9 +163,11 @@ export class AztecAddress {
   }
 
   static get schema(): ZodFor<AztecAddress> {
-    return hexSchemaFor(AztecAddress, AztecAddress.isAddress);
+    return z.union([
+      // Serialization from hex string.
+      hexSchemaFor(AztecAddress, AztecAddress.isAddress),
+      // Serialization from buffer.
+      bufferSchemaFor(AztecAddress, buf => buf.length === 32),
+    ]);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('AztecAddress', AztecAddress);

package/src/block/attestation_info.ts

@@ -1,9 +1,9 @@
-import { recoverAddress } from '@aztec/foundation/crypto';
+import { recoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 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 { L2Block } from './l2_block.js';
+import { type CoordinationSignatureContext, getHashedSignaturePayloadTypedData } from '../p2p/signature_utils.js';
 import type { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
@@ -29,17 +29,27 @@ export type AttestationInfo =
     };
 
 /**
- * Extracts attestation information from a published L2 block.
+ * Extracts attestation information from a published checkpoint.
  * Returns info for each attestation, preserving array indices.
  */
-export function getAttestationInfoFromPublishedL2Block(block: {
-  attestations: CommitteeAttestation[];
-  block: L2Block;
-}): AttestationInfo[] {
-  const payload = ConsensusPayload.fromBlock(block.block);
-  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+export function getAttestationInfoFromPublishedCheckpoint(
+  block: {
+    attestations: CommitteeAttestation[];
+    checkpoint: Checkpoint;
+  },
+  signatureContext: CoordinationSignatureContext,
+): AttestationInfo[] {
+  const payload = ConsensusPayload.fromCheckpoint(block.checkpoint, signatureContext);
+  return getAttestationInfoFromPayload(payload, block.attestations);
+}
+
+export function getAttestationInfoFromPayload(
+  payload: ConsensusPayload,
+  attestations: CommitteeAttestation[],
+): AttestationInfo[] {
+  const hashedPayload = getHashedSignaturePayloadTypedData(payload);
 
-  return block.attestations.map(attestation => {
+  return attestations.map(attestation => {
     // If signature is empty, check if we have an address directly
     if (attestation.signature.isEmpty()) {
       if (attestation.address.isZero()) {
@@ -52,7 +62,7 @@ export function getAttestationInfoFromPublishedL2Block(block: {
 
     // 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

@@ -0,0 +1,25 @@
+import { CheckpointNumberSchema, IndexWithinCheckpointSchema } from '@aztec/foundation/branded-types';
+import type { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+
+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: BlockHash;
+  checkpointNumber: CheckpointNumber;
+  indexWithinCheckpoint: IndexWithinCheckpoint;
+};
+
+export const BlockDataSchema = z.object({
+  header: BlockHeader.schema,
+  archive: AppendOnlyTreeSnapshot.schema,
+  blockHash: BlockHash.schema,
+  checkpointNumber: CheckpointNumberSchema,
+  indexWithinCheckpoint: IndexWithinCheckpointSchema,
+});

package/src/block/block_hash.ts

@@ -1,44 +1,52 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/fields';
-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 L2BlockHash extends Buffer32 {
-  constructor(
-    /** The buffer containing the hash. */
-    hash: Buffer,
-  ) {
+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);
   }
 
-  static override random() {
-    return new L2BlockHash(Fr.random().toBuffer());
+  [inspect.custom]() {
+    return `BlockHash<${this.toString()}>`;
   }
 
-  static override fromNumber(num: number): L2BlockHash {
-    return new L2BlockHash(super.fromNumber(num).toBuffer());
+  toFr(): Fr {
+    return new Fr(this.toBigInt());
   }
 
-  static override fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new L2BlockHash(reader.readBytes(L2BlockHash.SIZE));
+  /** Type guard that checks if a value is a BlockHash instance. */
+  static isBlockHash(value: unknown): value is BlockHash {
+    return value instanceof BlockHash;
   }
 
-  static override fromString(str: string): Buffer32 {
-    return new L2BlockHash(super.fromString(str).toBuffer());
+  static random() {
+    return new BlockHash(Fr.random());
   }
 
-  static get schema() {
-    return schemas.BufferHex.transform(value => new L2BlockHash(value));
+  static fromBuffer(buffer: Buffer | BufferReader): BlockHash {
+    return new BlockHash(Fr.fromBuffer(buffer));
   }
 
-  static zero() {
-    return new L2BlockHash(Buffer32.ZERO.toBuffer());
+  static fromString(str: string): BlockHash {
+    return new BlockHash(Fr.fromString(str));
   }
 
-  static override fromField(hash: Fr) {
-    return new L2BlockHash(hash.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);