@aztec/foundation 3.0.0-devnet.6 → 3.0.0-devnet.6-patch.1

package/src/crypto/bls/bn254_keystore.ts

@@ -0,0 +1,287 @@
+import { randomBytes } from '@aztec/foundation/crypto/random';
+
+import { createCipheriv, createDecipheriv, createHash, pbkdf2Sync, randomUUID } from 'crypto';
+import { readFileSync } from 'fs';
+import { z } from 'zod';
+
+/**
+ * BN254 Keystore Format
+ *
+ * Implements encryption and decryption of keystores for BN254 BLS private keys
+ * using PBKDF2 and AES-128-CTR. This format is inspired by EIP-2335 but adapted
+ * for BN254 keys rather than BLS12-381.
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-2335
+ */
+
+/**
+ * Zod schema for validating BN254 keystore structure
+ */
+const bn254KeystoreSchema = z.object({
+  crypto: z.object({
+    kdf: z.object({
+      function: z.literal('pbkdf2'),
+      params: z.object({
+        dklen: z.number(),
+        c: z.number(),
+        prf: z.string(),
+        salt: z.string(),
+      }),
+      message: z.string(),
+    }),
+    checksum: z.object({
+      function: z.literal('sha256'),
+      params: z.object({}),
+      message: z.string(),
+    }),
+    cipher: z.object({
+      function: z.literal('aes-128-ctr'),
+      params: z.object({
+        iv: z.string(),
+      }),
+      message: z.string(),
+    }),
+  }),
+  description: z.string().optional(),
+  pubkey: z.string(),
+  path: z.string(),
+  uuid: z.string(),
+  version: z.number(),
+});
+
+/**
+ * Error thrown when BN254 keystore operations fail
+ */
+export class Bn254KeystoreError extends Error {
+  constructor(
+    message: string,
+    public override cause?: Error,
+  ) {
+    super(message);
+    this.name = 'Bn254KeystoreError';
+  }
+}
+
+export type Bn254Keystore = z.infer<typeof bn254KeystoreSchema>;
+
+/**
+ * The JSON structure of a BN254 keystore file.
+ * @deprecated Use the inferred type from bn254KeystoreSchema instead
+ */
+export interface Bn254KeystoreInterface {
+  crypto: {
+    kdf: {
+      function: 'pbkdf2';
+      params: {
+        dklen: number;
+        c: number;
+        prf: string;
+        salt: string;
+      };
+      message: string;
+    };
+    checksum: {
+      function: 'sha256';
+      params: Record<string, never>;
+      message: string;
+    };
+    cipher: {
+      function: 'aes-128-ctr';
+      params: {
+        iv: string;
+      };
+      message: string;
+    };
+  };
+  description: string;
+  pubkey: string;
+  path: string;
+  uuid: string;
+  version: number;
+}
+
+/**
+ * Creates a BN254 keystore object for a BN254 BLS private key.
+ *
+ * Uses PBKDF2 with SHA-256 for key derivation and AES-128-CTR for encryption,
+ * following the EIP-2335 specification format.
+ *
+ * @param password - Password for encrypting the private key
+ * @param privateKeyHex - Private key as 0x-prefixed hex string (32 bytes)
+ * @param pubkeyHex - Public key as hex string (compressed or uncompressed)
+ * @param derivationPath - BIP-44 style derivation path (e.g., "m/12381/3600/0/0/0")
+ * @returns BN254 keystore object ready to be serialized to JSON
+ * @throws Error if private key is not 32-byte hex
+ */
+export function createBn254Keystore(
+  password: string,
+  privateKeyHex: string,
+  pubkeyHex: string,
+  derivationPath: string,
+): Bn254Keystore {
+  const ensureHex = (hex: string) => hex.replace(/^0x/i, '');
+  const privHex = ensureHex(privateKeyHex);
+  if (!/^[0-9a-fA-F]{64}$/.test(privHex)) {
+    throw new Error('BLS private key must be 32-byte hex');
+  }
+
+  const salt = randomBytes(32);
+  const iv = randomBytes(16);
+  const dk = pbkdf2Sync(Buffer.from(password.normalize('NFKD'), 'utf8'), salt, 262144, 32, 'sha256');
+  const cipherKey = dk.subarray(0, 16);
+
+  const cipher = createCipheriv('aes-128-ctr', cipherKey, iv);
+  const plaintext = Buffer.from(privHex, 'hex');
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+
+  const checksum = createHash('sha256')
+    .update(Buffer.concat([dk.subarray(16, 32), ciphertext]))
+    .digest();
+
+  const uuid = randomUUID();
+
+  return {
+    crypto: {
+      kdf: {
+        function: 'pbkdf2',
+        params: { dklen: 32, c: 262144, prf: 'hmac-sha256', salt: salt.toString('hex') },
+        message: '',
+      },
+      checksum: {
+        function: 'sha256',
+        params: {},
+        message: checksum.toString('hex'),
+      },
+      cipher: {
+        function: 'aes-128-ctr',
+        params: { iv: iv.toString('hex') },
+        message: ciphertext.toString('hex'),
+      },
+    },
+    description: ensureHex(pubkeyHex),
+    pubkey: pubkeyHex,
+    path: derivationPath ?? '',
+    uuid,
+    version: 4,
+  };
+}
+
+/**
+ * Loads and validates a BN254 keystore file.
+ *
+ * @param filePath - Path to the BN254 keystore JSON file
+ * @returns Validated keystore object
+ * @throws Bn254KeystoreError if file cannot be read or validated
+ */
+export function loadBn254Keystore(filePath: string): Bn254Keystore {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const json = JSON.parse(content);
+    return bn254KeystoreSchema.parse(json);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Bn254KeystoreError(`Invalid JSON in keystore file: ${filePath}`, error);
+    }
+    if (error && typeof error === 'object' && 'issues' in error) {
+      const issues = (error as any).issues ?? [];
+      const message = issues.map((e: any) => `${e.message} at ${e.path?.join('.') ?? 'root'}`).join('; ');
+      throw new Bn254KeystoreError(`Invalid BN254 keystore format: ${message}`);
+    }
+    throw new Bn254KeystoreError(`Failed to load keystore from ${filePath}: ${String(error)}`, error as Error);
+  }
+}
+
+/**
+ * Decrypts a BN254 BLS private key from a keystore file.
+ *
+ * @param filePath - Path to the BN254 keystore JSON file
+ * @param password - Password to decrypt the keystore
+ * @returns Decrypted private key as 0x-prefixed hex string (32 bytes)
+ * @throws Bn254KeystoreError if decryption fails or checksum is invalid
+ */
+export function decryptBn254Keystore(filePath: string, password: string): string {
+  const keystore = loadBn254Keystore(filePath);
+  return decryptBn254KeystoreFromObject(keystore, password);
+}
+
+/**
+ * Decrypts a BN254 BLS private key from a keystore object.
+ *
+ * @param keystore - BN254 keystore object
+ * @param password - Password to decrypt the keystore
+ * @returns Decrypted private key as 0x-prefixed hex string (32 bytes)
+ * @throws Bn254KeystoreError if decryption fails or checksum is invalid
+ */
+export function decryptBn254KeystoreFromObject(keystore: Bn254Keystore, password: string): string {
+  try {
+    const { crypto } = keystore;
+
+    // Only support PBKDF2 + AES-128-CTR (as per our implementation)
+    if (crypto.kdf.function !== 'pbkdf2') {
+      throw new Bn254KeystoreError(`Unsupported KDF function: ${crypto.kdf.function}`);
+    }
+    if (crypto.cipher.function !== 'aes-128-ctr') {
+      throw new Bn254KeystoreError(`Unsupported cipher function: ${crypto.cipher.function}`);
+    }
+
+    // Derive decryption key using PBKDF2
+    const salt = Buffer.from(crypto.kdf.params.salt, 'hex');
+    const dk = pbkdf2Sync(
+      Buffer.from(password.normalize('NFKD'), 'utf8'),
+      salt,
+      crypto.kdf.params.c,
+      crypto.kdf.params.dklen,
+      'sha256',
+    );
+
+    const cipherKey = dk.subarray(0, 16);
+    const checksumKey = dk.subarray(16, 32);
+
+    // Decrypt the ciphertext
+    const iv = Buffer.from(crypto.cipher.params.iv, 'hex');
+    const ciphertext = Buffer.from(crypto.cipher.message, 'hex');
+    const decipher = createDecipheriv('aes-128-ctr', cipherKey, iv);
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+
+    // Verify checksum
+    const computedChecksum = createHash('sha256')
+      .update(Buffer.concat([checksumKey, ciphertext]))
+      .digest();
+    const expectedChecksum = Buffer.from(crypto.checksum.message, 'hex');
+
+    if (!computedChecksum.equals(expectedChecksum)) {
+      throw new Bn254KeystoreError('Checksum verification failed - incorrect password or corrupted keystore');
+    }
+
+    // Return as 0x-prefixed hex
+    return '0x' + decrypted.toString('hex');
+  } catch (error) {
+    if (error instanceof Bn254KeystoreError) {
+      throw error;
+    }
+    throw new Bn254KeystoreError(`Failed to decrypt keystore: ${String(error)}`, error as Error);
+  }
+}
+
+/**
+ * Validates that a decrypted private key matches the public key in the keystore.
+ *
+ * @param privateKeyHex - Decrypted private key (0x-prefixed)
+ * @param expectedPubkey - Expected public key from keystore
+ * @param computePublicKey - Function to compute public key from private key
+ * @returns true if keys match, false otherwise
+ */
+export function verifyBn254Keypair(
+  privateKeyHex: string,
+  expectedPubkey: string,
+  computePublicKey: (privateKey: string) => string,
+): boolean {
+  try {
+    const computedPubkey = computePublicKey(privateKeyHex);
+    const normalizedExpected = expectedPubkey.toLowerCase().replace(/^0x/i, '');
+    const normalizedComputed = computedPubkey.toLowerCase().replace(/^0x/i, '');
+    return normalizedExpected === normalizedComputed;
+  } catch {
+    return false;
+  }
+}

package/src/crypto/bls/index.ts

@@ -0,0 +1,77 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Hex } from '@aztec/foundation/string';
+
+import { mod } from '@noble/curves/abstract/modular';
+import { bytesToNumberBE } from '@noble/curves/abstract/utils';
+import { hmac } from '@noble/hashes/hmac';
+import { sha512 } from '@noble/hashes/sha2';
+import { mnemonicToSeedSync } from '@scure/bip39';
+
+export function deriveBlsPrivateKey(mnemonic: string | undefined, ikm: string | undefined, path: string): Hex<32> {
+  if (ikm) {
+    return deriveBlsKeyFromEntropy(ikm, path) as Hex<32>;
+  }
+  if (!mnemonic) {
+    throw new Error('Either mnemonic or ikm must be provided for BLS derivation');
+  }
+  return deriveBlsKeyFromMnemonic(mnemonic, path) as Hex<32>;
+}
+
+/**
+ * Deterministically derive a BN254 BLS private key from mnemonic and derivation path.
+ * Returns a 0x-prefixed 32-byte hex string representing an Fr in [1, r-1].
+ */
+export function deriveBlsKeyFromMnemonic(mnemonic: string, derivationPath: string, passphrase = ''): string {
+  const seed = Buffer.from(mnemonicToSeedSync(mnemonic, passphrase)); // 64 bytes
+  const data = Buffer.concat([Buffer.from([0x00]), seed, Buffer.from(derivationPath, 'utf8')]);
+  const sk = deriveBn254ScalarFromData(data);
+  return `0x${toFixed32(sk).toString('hex')}`;
+}
+
+/**
+ * Deterministically derive a BN254 BLS private key from input keying material (IKM) and derivation path.
+ * Returns a 0x-prefixed 32-byte hex string representing an Fr in [1, r-1].
+ */
+export function deriveBlsKeyFromEntropy(ikm: string, derivationPath: string): string {
+  const ikmBytes = parseIkm(ikm);
+  const data = Buffer.concat([Buffer.from([0x01]), ikmBytes, Buffer.from(derivationPath, 'utf8')]);
+  const sk = deriveBn254ScalarFromData(data);
+  return `0x${toFixed32(sk).toString('hex')}`;
+}
+
+function deriveBn254ScalarFromData(data: Buffer): bigint {
+  // Domain-separated HMAC-SHA512, then map to BN254 Fr using noble modular math. Retry on zero.
+  const domainKey = Buffer.from('Aztec bn254 key', 'utf8');
+  for (let counter = 0; ; counter = (counter + 1) & 0xff) {
+    const msg = counter === 0 ? data : Buffer.concat([data, Buffer.from([counter])]);
+    const digest = hmac(sha512, domainKey, msg); // 64 bytes
+    const x = bytesToNumberBE(digest);
+    const sk = mod(x, Fr.MODULUS);
+    if (sk !== 0n) {
+      return sk;
+    }
+  }
+}
+
+function parseIkm(ikm: string): Buffer {
+  const hexMatch = ikm.replace(/^0x/i, '');
+  if (/^[0-9a-fA-F]+$/.test(hexMatch) && hexMatch.length >= 2) {
+    const normalized = hexMatch.length % 2 === 1 ? `0${hexMatch}` : hexMatch;
+    return Buffer.from(normalized, 'hex');
+  }
+  return Buffer.from(ikm, 'utf8');
+}
+
+function toFixed32(x: bigint): Buffer {
+  const hex = x.toString(16);
+  const padded = hex.length % 2 === 1 ? `0${hex}` : hex;
+  const buf = Buffer.from(padded, 'hex');
+  if (buf.length === 32) {
+    return buf;
+  }
+  if (buf.length < 32) {
+    return Buffer.concat([Buffer.alloc(32 - buf.length, 0), buf]);
+  }
+  // Should never happen since x < bn254.Fr.ORDER < 2^256, but guard anyway
+  return buf.subarray(buf.length - 32);
+}

package/src/crypto/bn254/index.ts

@@ -0,0 +1,64 @@
+import { Fr } from '../../curves/bn254/field.js';
+import { Bn254G1Point, Bn254G2Point } from '../../curves/bn254/point.js';
+
+/**
+ * BN254 utility functions for point operations.
+ * Provides compression, decompression, and public key generation for the BN254 curve.
+ * Uses the bb.js Barretenberg backend for point operations.
+ */
+
+/**
+ * Generate a compressed BN254 G1 public key from a private key.
+ *
+ * @param privateKeyHex - Private key as 0x-prefixed hex string
+ * @returns Compressed G1 point (32 bytes with sign bit in MSB)
+ */
+export async function computeBn254G1PublicKeyCompressed(privateKeyHex: string): Promise<string> {
+  const sk = BigInt(privateKeyHex);
+  const skReduced = sk % Fr.MODULUS;
+
+  // Generate G1 point on BN254 curve using bb.js
+  const scalar = Fr.fromString(skReduced.toString());
+  const pk1 = await Bn254G1Point.generator(scalar);
+
+  // Compress the point using the primitive method
+  return '0x' + pk1.compress().toString('hex');
+}
+
+/**
+ * Generate uncompressed BN254 G1 public key from a private key.
+ *
+ * @param privateKeyHex - Private key as 0x-prefixed hex string
+ * @returns G1 point in affine coordinates
+ */
+export async function computeBn254G1PublicKey(privateKeyHex: string): Promise<{ x: bigint; y: bigint }> {
+  const sk = BigInt(privateKeyHex);
+  const skReduced = sk % Fr.MODULUS;
+
+  const scalar = Fr.fromString(skReduced.toString());
+  const pk1 = await Bn254G1Point.generator(scalar);
+
+  return { x: pk1.x.toBigInt(), y: pk1.y.toBigInt() };
+}
+
+/**
+ * Generate BN254 G2 public key from a private key.
+ *
+ * @param privateKeyHex - Private key as 0x-prefixed hex string
+ * @returns G2 point in affine coordinates
+ */
+export async function computeBn254G2PublicKey(privateKeyHex: string): Promise<{
+  x: { c0: bigint; c1: bigint };
+  y: { c0: bigint; c1: bigint };
+}> {
+  const sk = BigInt(privateKeyHex);
+  const skReduced = sk % Fr.MODULUS;
+
+  const scalar = Fr.fromString(skReduced.toString());
+  const pk2 = await Bn254G2Point.generator(scalar);
+
+  return {
+    x: { c0: pk2.x[0].toBigInt(), c1: pk2.x[1].toBigInt() },
+    y: { c0: pk2.y[0].toBigInt(), c1: pk2.y[1].toBigInt() },
+  };
+}

package/src/crypto/ecdsa/index.ts

@@ -16,7 +16,7 @@ export class Ecdsa {
    * @returns A secp256k1 public key.
    */
   public async computePublicKey(privateKey: Buffer): Promise<Buffer> {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response =
       this.curve === 'secp256r1'
@@ -32,7 +32,7 @@ export class Ecdsa {
    * @returns An ECDSA signature of the form (r, s, v).
    */
   public async constructSignature(msg: Uint8Array, privateKey: Buffer) {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response =
       this.curve === 'secp256r1'
@@ -48,7 +48,7 @@ export class Ecdsa {
    * @returns The secp256k1 public key of the signer.
    */
   public async recoverPublicKey(msg: Uint8Array, sig: EcdsaSignature): Promise<Buffer> {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response =
       this.curve === 'secp256r1'
@@ -65,7 +65,7 @@ export class Ecdsa {
    * @returns True or false.
    */
   public async verifySignature(msg: Uint8Array, pubKey: Buffer, sig: EcdsaSignature) {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response =
       this.curve === 'secp256r1'

package/src/crypto/ecdsa/signature.ts

@@ -1,6 +1,6 @@
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { randomBytes } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { mapTuple } from '@aztec/foundation/serialize';
 
 import type { Signature } from '../signature/index.js';

package/src/crypto/grumpkin/index.ts

@@ -1,34 +1,28 @@
 import { BarretenbergSync } from '@aztec/bb.js';
-import { Fr, type GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 
 /**
  * Grumpkin elliptic curve operations.
  */
 export class Grumpkin {
   // prettier-ignore
-  static generator = Point.fromBuffer(Buffer.from([
+  static readonly generator = Point.fromBuffer(Buffer.from([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xcf, 0x13, 0x5e, 0x75, 0x06, 0xa4, 0x5d, 0x63,
     0x2d, 0x27, 0x0d, 0x45, 0xf1, 0x18, 0x12, 0x94, 0x83, 0x3f, 0xc4, 0x8d, 0x82, 0x3f, 0x27, 0x2c,
   ]));
 
-  /**
-   * Point generator
-   * @returns The generator for the curve.
-   */
-  public generator(): Point {
-    return Grumpkin.generator;
-  }
-
   /**
    * Multiplies a point by a scalar (adds the point `scalar` amount of times).
    * @param point - Point to multiply.
    * @param scalar - Scalar to multiply by.
    * @returns Result of the multiplication.
    */
-  public async mul(point: Point, scalar: GrumpkinScalar): Promise<Point> {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  public static async mul(point: Point, scalar: GrumpkinScalar): Promise<Point> {
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response = api.grumpkinMul({
       point: { x: point.x.toBuffer(), y: point.y.toBuffer() },
@@ -43,8 +37,8 @@ export class Grumpkin {
    * @param b - Point b to add to a
    * @returns Result of the addition.
    */
-  public async add(a: Point, b: Point): Promise<Point> {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  public static async add(a: Point, b: Point): Promise<Point> {
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response = api.grumpkinAdd({
       pointA: { x: a.x.toBuffer(), y: a.y.toBuffer() },
@@ -59,8 +53,8 @@ export class Grumpkin {
    * @param scalar - Scalar to multiply by.
    * @returns Points multiplied by the scalar.
    */
-  public async batchMul(points: Point[], scalar: GrumpkinScalar) {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  public static async batchMul(points: Point[], scalar: GrumpkinScalar) {
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response = api.grumpkinBatchMul({
       points: points.map(p => ({ x: p.x.toBuffer(), y: p.y.toBuffer() })),
@@ -74,8 +68,8 @@ export class Grumpkin {
    * Gets a random field element.
    * @returns Random field element.
    */
-  public async getRandomFr(): Promise<Fr> {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  public static async getRandomFr(): Promise<Fr> {
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response = api.grumpkinGetRandomFr({ dummy: 0 });
     return Fr.fromBuffer(Buffer.from(response.value));
@@ -86,8 +80,8 @@ export class Grumpkin {
    * @param uint512Buf - The buffer to convert.
    * @returns Buffer representation of the field element.
    */
-  public async reduce512BufferToFr(uint512Buf: Buffer): Promise<Fr> {
-    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  public static async reduce512BufferToFr(uint512Buf: Buffer): Promise<Fr> {
+    await BarretenbergSync.initSingleton();
     const api = BarretenbergSync.getSingleton();
     const response = api.grumpkinReduce512({ input: uint512Buf });
     return Fr.fromBuffer(Buffer.from(response.value));

package/src/crypto/keys/index.ts

@@ -1,9 +1,9 @@
 import { BarretenbergSync } from '@aztec/bb.js';
 
-import { Fr } from '../../fields/fields.js';
+import { Fr } from '../../curves/bn254/field.js';
 
 export async function vkAsFieldsMegaHonk(input: Buffer): Promise<Fr[]> {
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.megaVkAsFields({ verificationKey: input });
   return response.fields.map(field => Fr.fromBuffer(Buffer.from(field)));

package/src/crypto/pedersen/pedersen.wasm.ts

@@ -1,6 +1,6 @@
 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,7 +12,7 @@ export async 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));
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.pedersenCommit({
     inputs: input,
@@ -29,7 +29,7 @@ export async function pedersenCommit(input: Buffer[], offset = 0) {
  */
 export async function pedersenHash(input: Fieldable[], index = 0): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.pedersenHash({
     inputs: inputFields.map(i => i.toBuffer()),
@@ -42,7 +42,7 @@ export async function pedersenHash(input: Fieldable[], index = 0): Promise<Fr> {
  * Create a pedersen hash from an arbitrary length buffer.
  */
 export async function pedersenHashBuffer(input: Buffer, index = 0) {
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.pedersenHashBuffer({
     input,

package/src/crypto/poseidon/index.ts

@@ -1,6 +1,6 @@
 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,7 +10,7 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  */
 export async function poseidon2Hash(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.poseidon2Hash({
     inputs: inputFields.map(i => i.toBuffer()),
@@ -27,7 +27,7 @@ export async function poseidon2Hash(input: Fieldable[]): Promise<Fr> {
 export async function poseidon2HashWithSeparator(input: Fieldable[], separator: number): Promise<Fr> {
   const inputFields = serializeToFields(input);
   inputFields.unshift(new Fr(separator));
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.poseidon2Hash({
     inputs: inputFields.map(i => i.toBuffer()),
@@ -37,7 +37,7 @@ export async function poseidon2HashWithSeparator(input: Fieldable[], separator:
 
 export async function poseidon2HashAccumulate(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.poseidon2HashAccumulate({
     inputs: inputFields.map(i => i.toBuffer()),
@@ -54,7 +54,7 @@ export async function poseidon2Permutation(input: Fieldable[]): Promise<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');
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.poseidon2Permutation({
     inputs: inputFields.map(i => i.toBuffer()),
@@ -75,7 +75,7 @@ export async function poseidon2HashBytes(input: Buffer): Promise<Fr> {
     inputFields.push(Fr.fromBuffer(fieldBytes));
   }
 
-  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  await BarretenbergSync.initSingleton();
   const api = BarretenbergSync.getSingleton();
   const response = api.poseidon2Hash({
     inputs: inputFields.map(i => i.toBuffer()),