@aztec/foundation 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/src/crypto/sync/pedersen/index.ts

@@ -1,6 +1,6 @@
-import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
-import { Fr } from '../../../fields/fields.js';
+import { Fr } from '../../../curves/bn254/field.js';
 import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
 
 /**
@@ -12,13 +12,11 @@ export function pedersenCommit(input: Buffer[], offset = 0) {
     throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
   }
   input = input.map(i => (i.length < 32 ? Buffer.concat([Buffer.alloc(32 - i.length, 0), i]) : i));
-  const point = BarretenbergSync.getSingleton().pedersenCommit(
-    input.map(i => new FrBarretenberg(i)),
-    offset,
-  );
-  // toBuffer returns Uint8Arrays (browser/worker-boundary friendly).
-  // TODO: rename toTypedArray()?
-  return [Buffer.from(point.x.toBuffer()), Buffer.from(point.y.toBuffer())];
+  const response = BarretenbergSync.getSingleton().pedersenCommit({
+    inputs: input,
+    hashIndex: offset,
+  });
+  return [Buffer.from(response.point.x), Buffer.from(response.point.y)];
 }
 
 /**
@@ -29,17 +27,20 @@ export function pedersenCommit(input: Buffer[], offset = 0) {
  */
 export function pedersenHash(input: Fieldable[], index = 0): Fr {
   const inputFields = serializeToFields(input);
-  const hash = BarretenbergSync.getSingleton().pedersenHash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-    index,
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  const response = BarretenbergSync.getSingleton().pedersenHash({
+    inputs: inputFields.map(i => i.toBuffer()),
+    hashIndex: index,
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 /**
  * Create a pedersen hash from an arbitrary length buffer.
  */
 export function pedersenHashBuffer(input: Buffer, index = 0) {
-  const result = BarretenbergSync.getSingleton().pedersenHashBuffer(input, index);
-  return Buffer.from(result.toBuffer());
+  const response = BarretenbergSync.getSingleton().pedersenHashBuffer({
+    input,
+    hashIndex: index,
+  });
+  return Buffer.from(response.hash);
 }

package/src/crypto/sync/poseidon/index.ts

@@ -1,6 +1,6 @@
-import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
-import { Fr } from '../../../fields/fields.js';
+import { Fr } from '../../../curves/bn254/field.js';
 import { type Fieldable, serializeToFields } from '../../../serialize/serialize.js';
 
 /**
@@ -10,10 +10,11 @@ import { type Fieldable, serializeToFields } from '../../../serialize/serialize.
  */
 export function poseidon2Hash(input: Fieldable[]): Fr {
   const inputFields = serializeToFields(input);
-  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 /**
@@ -26,18 +27,20 @@ export function poseidon2HashWithSeparator(input: Fieldable[], separator: number
   const inputFields = serializeToFields(input);
   inputFields.unshift(new Fr(separator));
 
-  const hash = BarretenbergSync.getSingleton().poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 export function poseidon2HashAccumulate(input: Fieldable[]): Fr {
   const inputFields = serializeToFields(input);
-  const result = BarretenbergSync.getSingleton().poseidon2HashAccumulate(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
-  );
-  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2HashAccumulate({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 /**
@@ -49,12 +52,13 @@ export function poseidon2Permutation(input: Fieldable[]): Fr[] {
   const inputFields = serializeToFields(input);
   // We'd like this assertion but it's not possible to use it in the browser.
   // assert(input.length === 4, 'Input state must be of size 4');
-  const res = BarretenbergSync.getSingleton().poseidon2Permutation(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())),
-  );
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Permutation({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
   // We'd like this assertion but it's not possible to use it in the browser.
-  // assert(res.length === 4, 'Output state must be of size 4');
-  return res.map(o => Fr.fromBuffer(Buffer.from(o.toBuffer())));
+  // assert(response.outputs.length === 4, 'Output state must be of size 4');
+  return response.outputs.map(o => Fr.fromBuffer(Buffer.from(o)));
 }
 
 export function poseidon2HashBytes(input: Buffer): Fr {
@@ -68,9 +72,10 @@ export function poseidon2HashBytes(input: Buffer): Fr {
     inputFields.push(Fr.fromBuffer(fieldBytes));
   }
 
-  const res = BarretenbergSync.getSingleton().poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
 
-  return Fr.fromBuffer(Buffer.from(res.toBuffer()));
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }

package/src/{fields/bls12_fields.ts → curves/bls12/field.ts}

@@ -2,12 +2,12 @@
 import { bls12_381 } from '@noble/curves/bls12-381';
 import { inspect } from 'util';
 
-import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
-import { randomBytes } from '../crypto/random/index.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { BufferReader } from '../serialize/buffer_reader.js';
-import { TypeRegistry } from '../serialize/type_registry.js';
-import { Fr } from './fields.js';
+import { toBigIntBE, toBufferBE } from '../../bigint-buffer/index.js';
+import { randomBytes } from '../../crypto/random/index.js';
+import { hexSchemaFor } from '../../schemas/utils.js';
+import { BufferReader } from '../../serialize/buffer_reader.js';
+import { TypeRegistry } from '../../serialize/type_registry.js';
+import { Fr } from '../bn254/field.js';
 
 /**
  * Represents a field derived from BLS12Field.

package/src/curves/bls12/index.ts

@@ -0,0 +1,2 @@
+export * from './field.js';
+export * from './point.js';

package/src/{fields/bls12_point.ts → curves/bls12/point.ts}

@@ -3,13 +3,13 @@ import type { ProjPointType } from '@noble/curves/abstract/weierstrass';
 import { bls12_381 } from '@noble/curves/bls12-381';
 import { inspect } from 'util';
 
-import { toBufferBE } from '../bigint-buffer/index.js';
-import { randomBoolean } from '../crypto/random/index.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { BufferReader, serializeToBuffer } from '../serialize/index.js';
-import { bufferToHex, hexToBuffer } from '../string/index.js';
-import { BLS12Fq, BLS12Fr } from './bls12_fields.js';
-import { Fr } from './fields.js';
+import { toBufferBE } from '../../bigint-buffer/index.js';
+import { randomBoolean } from '../../crypto/random/index.js';
+import { hexSchemaFor } from '../../schemas/utils.js';
+import { BufferReader, serializeToBuffer } from '../../serialize/index.js';
+import { bufferToHex, hexToBuffer } from '../../string/index.js';
+import { Fr } from '../bn254/field.js';
+import { BLS12Fq, BLS12Fr } from './field.js';
 
 /**
  * Represents a Point on an elliptic curve with x and y coordinates.
@@ -158,13 +158,13 @@ export class BLS12Point {
   }
 
   /**
-   * Converts a Point to two BN254 Fr elements by storing its compressed form as:
-   * +------------------+------------------+
-   * | Field Element 1  | Field Element 2  |
-   * | [bytes 0-31]     | [bytes 32-47]   |
-   * +------------------+------------------+
-   * |     32 bytes     |     16 bytes    |
-   * +------------------+------------------+
+   * Converts a Point to two BN254 Fr elements by storing its compressed form (48 bytes) as:
+   * +-------------------+------------------------+
+   * |      31 bytes     |         17 bytes       |
+   * +-------------------+------------------------+
+   * |  Field Element 1  |     Field Element 2    |
+   * |  [0][bytes 0-30]  |  [0...0][bytes 31-47]  |
+   * +-------------------+------------------------+
    * Used in the rollup circuits to store blob commitments in the native field type. See blob.ts.
    * @param point - A BLS12Point instance.
    * @returns The point fields.

package/src/{fields/fields.ts → curves/bn254/field.ts}

@@ -2,11 +2,11 @@ import { BarretenbergSync } from '@aztec/bb.js';
 
 import { inspect } from 'util';
 
-import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
-import { randomBytes } from '../crypto/random/index.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { BufferReader } from '../serialize/buffer_reader.js';
-import { TypeRegistry } from '../serialize/type_registry.js';
+import { toBigIntBE, toBufferBE } from '../../bigint-buffer/index.js';
+import { randomBytes } from '../../crypto/random/index.js';
+import { hexSchemaFor } from '../../schemas/utils.js';
+import { BufferReader } from '../../serialize/buffer_reader.js';
+import { TypeRegistry } from '../../serialize/type_registry.js';
 
 const ZERO_BUFFER = Buffer.alloc(32);
 
@@ -321,22 +321,37 @@ export class Fr extends BaseField {
    * @returns A square root of the field element (null if it does not exist).
    */
   async sqrt(): Promise<Fr | null> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const wasm = api.getWasm();
-    const [buf] = wasm.callWasmExport('bn254_fr_sqrt', [this.toBuffer()], [Fr.SIZE_IN_BYTES + 1]);
-    const isSqrt = buf[0] === 1;
-    if (!isSqrt) {
+    await BarretenbergSync.initSingleton();
+    const api = BarretenbergSync.getSingleton();
+    const response = api.bn254FrSqrt({ input: this.toBuffer() });
+    if (!response.isSquareRoot) {
       // Field element is not a quadratic residue mod p so it has no square root.
       return null;
     }
-    return new Fr(Buffer.from(buf.slice(1)));
+    return Fr.fromBuffer(Buffer.from(response.value));
   }
 
   toJSON() {
     return this.toString();
   }
 
+  /**
+   * Creates an Fr 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).
+   * Handles buffers, strings, numbers, bigints, or existing instances.
+   * @param obj - Plain object, buffer, string, number, bigint, boolean, or Fr instance
+   * @returns An Fr instance
+   */
+  static fromPlainObject(obj: any): Fr {
+    if (obj instanceof Fr) {
+      return obj;
+    }
+    return new Fr(obj);
+  }
+
   static get schema() {
+    // Serialization from hex string.
     return hexSchemaFor(Fr);
   }
 }
@@ -435,6 +450,21 @@ export class Fq extends BaseField {
     return new Fq((this.toBigInt() + rhs.toBigInt()) % Fq.MODULUS);
   }
 
+  /**
+   * Computes a square root of the field element.
+   * @returns A square root of the field element (null if it does not exist).
+   */
+  async sqrt(): Promise<Fq | null> {
+    await BarretenbergSync.initSingleton();
+    const api = BarretenbergSync.getSingleton();
+    const response = api.bn254FqSqrt({ input: this.toBuffer() });
+    if (!response.isSquareRoot) {
+      // Field element is not a quadratic residue mod p so it has no square root.
+      return null;
+    }
+    return Fq.fromBuffer(Buffer.from(response.value));
+  }
+
   toJSON() {
     return this.toString();
   }
@@ -481,14 +511,6 @@ function extendedEuclidean(a: bigint, modulus: bigint): [bigint, bigint, bigint]
   }
 }
 
-/**
- * GrumpkinScalar is an Fq.
- * @remarks Called GrumpkinScalar because it is used to represent elements in Grumpkin's scalar field as defined in
- *          the Aztec Protocol Specs.
- */
-export type GrumpkinScalar = Fq;
-export const GrumpkinScalar = Fq;
-
 /** Wraps a function that returns a buffer so that all results are reduced into a field of the given type. */
 export function reduceFn<TInput, TField extends BaseField>(fn: (input: TInput) => Buffer, field: DerivedField<TField>) {
   return (input: TInput) => fromBufferReduce(fn(input), field);

package/src/curves/bn254/index.ts

@@ -0,0 +1,2 @@
+export * from './field.js';
+export * from './point.js';

package/src/curves/bn254/point.ts

@@ -0,0 +1,170 @@
+import {
+  BN254_G1_GENERATOR,
+  BN254_G2_GENERATOR,
+  BarretenbergSync,
+  type Bn254G1Point as BbApiBn254G1Point,
+  type Bn254G2Point as BbApiBn254G2Point,
+} from '@aztec/bb.js';
+
+import { Fq, Fr } from './field.js';
+
+/**
+ * BN254 G1 point using foundation field classes.
+ * Represents a point on the BN254 elliptic curve in affine coordinates.
+ */
+export class Bn254G1Point {
+  constructor(
+    public readonly x: Fq,
+    public readonly y: Fq,
+  ) {}
+
+  private toBbApiPoint(): BbApiBn254G1Point {
+    return {
+      x: this.x.toBuffer(),
+      y: this.y.toBuffer(),
+    };
+  }
+
+  private static fromBbApiPoint(point: BbApiBn254G1Point): Bn254G1Point {
+    return new Bn254G1Point(Fq.fromBuffer(Buffer.from(point.x)), Fq.fromBuffer(Buffer.from(point.y)));
+  }
+
+  async isOnCurve(): Promise<boolean> {
+    await BarretenbergSync.initSingleton();
+    const api = BarretenbergSync.getSingleton();
+
+    const apiPoint = this.toBbApiPoint();
+    const response = api.bn254G1IsOnCurve({ point: apiPoint });
+    return response.isOnCurve;
+  }
+
+  /**
+   * Get the generator point for BN254 G1, or perform scalar multiplication.
+   * When called without arguments, returns the base generator point.
+   * When called with a scalar, returns scalar * generator (useful for public key derivation).
+   */
+  static async generator(scalar?: Fr): Promise<Bn254G1Point> {
+    if (!scalar) {
+      return new Bn254G1Point(
+        Fq.fromBuffer(Buffer.from(BN254_G1_GENERATOR.x)),
+        Fq.fromBuffer(Buffer.from(BN254_G1_GENERATOR.y)),
+      );
+    }
+
+    await BarretenbergSync.initSingleton();
+    const api = BarretenbergSync.getSingleton();
+
+    const response = api.bn254G1Mul({
+      point: BN254_G1_GENERATOR,
+      scalar: scalar.toBuffer(),
+    });
+
+    return Bn254G1Point.fromBbApiPoint(response.point);
+  }
+
+  /**
+   * Decompress a BN254 G1 point from compressed form (32 bytes).
+   * The compressed format encodes the x-coordinate and the sign bit of the y-coordinate
+   * in the most significant bit.
+   */
+  static async fromCompressed(compressed: Buffer): Promise<Bn254G1Point> {
+    if (compressed.length !== 32) {
+      throw new Error('Invalid compressed point length');
+    }
+    await BarretenbergSync.initSingleton();
+    const api = BarretenbergSync.getSingleton();
+
+    const response = api.bn254G1FromCompressed({
+      compressed: new Uint8Array(compressed),
+    });
+
+    return Bn254G1Point.fromBbApiPoint(response.point);
+  }
+
+  /**
+   * Compress this BN254 G1 point to 32 bytes.
+   * The compressed format encodes the x-coordinate and the sign bit of the y-coordinate
+   * in the most significant bit (bit 255).
+   */
+  compress(): Buffer {
+    const xBytes = this.x.toBuffer();
+    // Get the least significant bit of y to determine the sign
+    const yLsb = this.y.toBigInt() & 1n;
+    // If y is odd, set the most significant bit (bit 255) of the output
+    if (yLsb === 1n) {
+      xBytes[0] |= 0x80;
+    }
+    return xBytes;
+  }
+
+  equals(other: Bn254G1Point): boolean {
+    return this.x.equals(other.x) && this.y.equals(other.y);
+  }
+
+  toString(): string {
+    return `Bn254G1Point(x: ${this.x.toString()}, y: ${this.y.toString()})`;
+  }
+}
+
+/**
+ * BN254 G2 point using foundation field classes.
+ * Represents a point on the BN254 G2 curve (twist curve) in affine coordinates.
+ * G2 points use extension field coordinates (Fq2).
+ */
+export class Bn254G2Point {
+  constructor(
+    public readonly x: [Fq, Fq],
+    public readonly y: [Fq, Fq],
+  ) {}
+
+  private toBbApiPoint(): BbApiBn254G2Point {
+    return {
+      x: [this.x[0].toBuffer(), this.x[1].toBuffer()],
+      y: [this.y[0].toBuffer(), this.y[1].toBuffer()],
+    };
+  }
+
+  private static fromBbApiPoint(point: BbApiBn254G2Point): Bn254G2Point {
+    return new Bn254G2Point(
+      [Fq.fromBuffer(Buffer.from(point.x[0])), Fq.fromBuffer(Buffer.from(point.x[1]))],
+      [Fq.fromBuffer(Buffer.from(point.y[0])), Fq.fromBuffer(Buffer.from(point.y[1]))],
+    );
+  }
+
+  /**
+   * Get the generator point for BN254 G2, or perform scalar multiplication.
+   * When called without arguments, returns the base generator point.
+   * When called with a scalar, returns scalar * generator.
+   */
+  static async generator(scalar?: Fr): Promise<Bn254G2Point> {
+    if (!scalar) {
+      return new Bn254G2Point(
+        [Fq.fromBuffer(Buffer.from(BN254_G2_GENERATOR.x[0])), Fq.fromBuffer(Buffer.from(BN254_G2_GENERATOR.x[1]))],
+        [Fq.fromBuffer(Buffer.from(BN254_G2_GENERATOR.y[0])), Fq.fromBuffer(Buffer.from(BN254_G2_GENERATOR.y[1]))],
+      );
+    }
+
+    await BarretenbergSync.initSingleton();
+    const api = BarretenbergSync.getSingleton();
+
+    const response = api.bn254G2Mul({
+      point: BN254_G2_GENERATOR as BbApiBn254G2Point,
+      scalar: scalar.toBuffer(),
+    });
+
+    return Bn254G2Point.fromBbApiPoint(response.point);
+  }
+
+  equals(other: Bn254G2Point): boolean {
+    return (
+      this.x[0].equals(other.x[0]) &&
+      this.x[1].equals(other.x[1]) &&
+      this.y[0].equals(other.y[0]) &&
+      this.y[1].equals(other.y[1])
+    );
+  }
+
+  toString(): string {
+    return `Bn254G2Point(x: (${this.x[0].toString()}, ${this.x[1].toString()}), y: (${this.y[0].toString()}, ${this.y[1].toString()}))`;
+  }
+}

package/src/curves/grumpkin/index.ts

@@ -0,0 +1,11 @@
+import { Fq } from '../bn254/field.js';
+
+export * from './point.js';
+
+/**
+ * GrumpkinScalar is an Fq.
+ * @remarks Called GrumpkinScalar because it is used to represent elements in Grumpkin's scalar field as defined in
+ *          the Aztec Protocol Specs.
+ */
+export type GrumpkinScalar = Fq;
+export const GrumpkinScalar = Fq;

package/src/{fields → curves/grumpkin}/point.ts

@@ -1,10 +1,10 @@
-import { toBigIntBE } from '../bigint-buffer/index.js';
-import { poseidon2Hash } from '../crypto/poseidon/index.js';
-import { randomBoolean } from '../crypto/random/index.js';
-import { hexSchemaFor } from '../schemas/utils.js';
-import { BufferReader, FieldReader, serializeToBuffer } from '../serialize/index.js';
-import { bufferToHex, hexToBuffer } from '../string/index.js';
-import { Fr } from './fields.js';
+import { toBigIntBE } from '../../bigint-buffer/index.js';
+import { poseidon2Hash } from '../../crypto/poseidon/index.js';
+import { randomBoolean } from '../../crypto/random/index.js';
+import { hexSchemaFor } from '../../schemas/utils.js';
+import { BufferReader, FieldReader, serializeToBuffer } from '../../serialize/index.js';
+import { bufferToHex, hexToBuffer } from '../../string/index.js';
+import { Fr } from '../bn254/field.js';
 
 /**
  * Represents a Point on an elliptic curve with x and y coordinates.
@@ -42,9 +42,28 @@ export class Point {
   }
 
   static get schema() {
+    // Serialization from hex string.
     return hexSchemaFor(Point);
   }
 
+  /**
+   * Creates a Point 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, existing instances, or objects with x, y, and isInfinite fields.
+   * @param obj - Plain object, buffer, or Point instance
+   * @returns A Point instance
+   */
+  static fromPlainObject(obj: any): Point {
+    if (obj instanceof Point) {
+      return obj;
+    }
+    if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
+      return Point.fromBuffer(obj);
+    }
+    return new Point(Fr.fromPlainObject(obj.x), Fr.fromPlainObject(obj.y), obj.isInfinite ?? false);
+  }
+
   /**
    * Generate a random Point instance.
    *

package/src/eth-address/index.ts

@@ -2,7 +2,7 @@ import { inspect } from 'util';
 
 import { keccak256String } from '../crypto/keccak/index.js';
 import { randomBytes } from '../crypto/random/index.js';
-import { Fr } from '../fields/index.js';
+import { Fr } from '../curves/bn254/index.js';
 import { hexSchemaFor } from '../schemas/utils.js';
 import { BufferReader, FieldReader } from '../serialize/index.js';
 import { TypeRegistry } from '../serialize/type_registry.js';
@@ -41,6 +41,24 @@ export class EthAddress {
     return new EthAddress(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
   }
 
+  /**
+   * Creates an EthAddress 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 (20 or 32 bytes), strings, or existing instances.
+   * @param obj - Plain object, buffer, string, or EthAddress instance
+   * @returns An EthAddress instance
+   */
+  public static fromPlainObject(obj: any): EthAddress {
+    if (obj instanceof EthAddress) {
+      return obj;
+    }
+    if (obj instanceof Buffer || Buffer.isBuffer(obj)) {
+      return obj.length === 20 ? new EthAddress(obj) : EthAddress.fromField(new Fr(obj));
+    }
+    return EthAddress.fromString(obj);
+  }
+
   /**
    * Create a random EthAddress instance with 20 random bytes.
    * This method generates a new Ethereum address with a randomly generated set of 20 bytes.
@@ -117,14 +135,14 @@ export class EthAddress {
    * @param address - The Ethereum address as a hex-encoded string.
    * @returns The Ethereum address in its checksum format.
    */
-  public static toChecksumAddress(address: string) {
+  public static toChecksumAddress(address: string): `0x${string}` {
     if (!EthAddress.isAddress(address)) {
       throw new Error('Invalid address string.');
     }
 
     address = address.toLowerCase().replace(/^0x/i, '');
     const addressHash = keccak256String(address);
-    let checksumAddress = '0x';
+    let checksumAddress: `0x${string}` = '0x';
 
     for (let i = 0; i < address.length; i++) {
       // If ith character is 9 to f then make it uppercase.
@@ -240,8 +258,15 @@ export class EthAddress {
   }
 
   static get schema() {
+    // Serialization from hex string.
     return hexSchemaFor(EthAddress, EthAddress.isAddress);
   }
+
+  static areEqual(a: EthAddress | string, b: EthAddress | string) {
+    const addrA = typeof a === 'string' ? EthAddress.fromString(a) : a;
+    const addrB = typeof b === 'string' ? EthAddress.fromString(b) : b;
+    return addrA.equals(addrB);
+  }
 }
 
 // For deserializing JSON.

package/src/eth-signature/eth_signature.ts

@@ -78,7 +78,7 @@ export class Signature {
   }
 
   static random(): Signature {
-    return new Signature(Buffer32.random(), Buffer32.random(), Math.floor(Math.random() * 2));
+    return new Signature(Buffer32.random(), Buffer32.random(), 1);
   }
 
   static empty(): Signature {
@@ -94,9 +94,7 @@ export class Signature {
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.r, this.s, this.v]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.r, this.s, this.v]);
   }
 
   getSize(): number {

package/src/json-rpc/client/safe_json_rpc_client.ts

@@ -178,6 +178,15 @@ export function createSafeJsonRpcClient<T extends object>(
         }
       }
     } catch (err) {
+      // Re-throw ComponentsVersionsError immediately without converting to JSON-RPC error
+      // This ensures version mismatch errors are surfaced to the user instead of being hidden
+      if (err && typeof err === 'object' && 'name' in err && err.name === 'ComponentsVersionsError') {
+        // Reject all pending requests with the version error
+        for (let i = 0; i < rpcCalls.length; i++) {
+          rpcCalls[i].deferred.reject(err);
+        }
+        return; // Return early, the promises are already rejected
+      }
       log.warn(`Failed to fetch from the remote server`, err);
       for (let i = 0; i < rpcCalls.length; i++) {
         const { request, deferred } = rpcCalls[i];

package/src/log/log_fn.ts

@@ -1,5 +1,5 @@
 /** Structured log data to include with the message. */
-export type LogData = Record<string, string | number | bigint | boolean | { toString(): string } | undefined>;
+export type LogData = Record<string, string | number | bigint | boolean | { toString(): string } | undefined | null>;
 
 /** A callable logger instance. */
 export type LogFn = (msg: string, data?: unknown) => void;

package/src/log/pino-logger.ts

@@ -111,7 +111,6 @@ const redactedPaths = [
   // bot keys
   'l1PrivateKey',
   'senderPrivateKey',
-  'recipientEncryptionSecret',
   // blob sink
   'l1ConsensusHostApiKeys',
   // sensitive options used in the CLI

package/src/profiler/index.ts

@@ -0,0 +1 @@
+export * from './profiler.js';