@aztec/foundation 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/crypto/aes128/index.ts

@@ -1,4 +1,4 @@
-import { BarretenbergSync, RawBuffer } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { Buffer } from 'buffer';
 
@@ -22,10 +22,15 @@ export class Aes128 {
     paddingBuffer.fill(numPaddingBytes);
     const input = Buffer.concat([data, paddingBuffer]);
 
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    return Buffer.from(
-      api.aesEncryptBufferCbc(new RawBuffer(input), new RawBuffer(iv), new RawBuffer(key), input.length),
-    );
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.aesEncrypt({
+      plaintext: input,
+      iv,
+      key,
+      length: input.length,
+    });
+    return Buffer.from(response.ciphertext);
   }
 
   /**
@@ -37,11 +42,15 @@ export class Aes128 {
    * @returns Decrypted data.
    */
   public async decryptBufferCBCKeepPadding(data: Uint8Array, iv: Uint8Array, key: Uint8Array): Promise<Buffer> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const paddedBuffer = Buffer.from(
-      api.aesDecryptBufferCbc(new RawBuffer(data), new RawBuffer(iv), new RawBuffer(key), data.length),
-    );
-    return paddedBuffer;
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.aesDecrypt({
+      ciphertext: data,
+      iv,
+      key,
+      length: data.length,
+    });
+    return Buffer.from(response.plaintext);
   }
 
   /**

package/src/crypto/ecdsa/index.ts

@@ -1,7 +1,5 @@
 import { BarretenbergSync } from '@aztec/bb.js';
-import { numToInt32BE } from '@aztec/foundation/serialize';
 
-import { concatenateUint8Arrays } from '../serialize.js';
 import { EcdsaSignature } from './signature.js';
 
 export * from './signature.js';
@@ -18,11 +16,13 @@ export class Ecdsa {
    * @returns A secp256k1 public key.
    */
   public async computePublicKey(privateKey: Buffer): Promise<Buffer> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api
-      .getWasm()
-      .callWasmExport(`ecdsa_${this.curve === 'secp256r1' ? 'r' : ''}_compute_public_key`, [privateKey], [64]);
-    return Buffer.from(result);
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response =
+      this.curve === 'secp256r1'
+        ? api.ecdsaSecp256r1ComputePublicKey({ privateKey })
+        : api.ecdsaSecp256k1ComputePublicKey({ privateKey });
+    return Buffer.concat([Buffer.from(response.publicKey.x), Buffer.from(response.publicKey.y)]);
   }
 
   /**
@@ -32,16 +32,13 @@ export class Ecdsa {
    * @returns An ECDSA signature of the form (r, s, v).
    */
   public async constructSignature(msg: Uint8Array, privateKey: Buffer) {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const messageArray = concatenateUint8Arrays([numToInt32BE(msg.length), msg]);
-    const [r, s, v] = api
-      .getWasm()
-      .callWasmExport(
-        `ecdsa_${this.curve === 'secp256r1' ? 'r' : ''}_construct_signature_`,
-        [messageArray, privateKey],
-        [32, 32, 1],
-      );
-    return new EcdsaSignature(Buffer.from(r), Buffer.from(s), Buffer.from(v));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response =
+      this.curve === 'secp256r1'
+        ? api.ecdsaSecp256r1ConstructSignature({ message: msg, privateKey })
+        : api.ecdsaSecp256k1ConstructSignature({ message: msg, privateKey });
+    return new EcdsaSignature(Buffer.from(response.r), Buffer.from(response.s), Buffer.from([response.v]));
   }
 
   /**
@@ -51,16 +48,13 @@ export class Ecdsa {
    * @returns The secp256k1 public key of the signer.
    */
   public async recoverPublicKey(msg: Uint8Array, sig: EcdsaSignature): Promise<Buffer> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const messageArray = concatenateUint8Arrays([numToInt32BE(msg.length), msg]);
-    const [result] = api
-      .getWasm()
-      .callWasmExport(
-        `ecdsa_${this.curve === 'secp256r1' ? 'r' : ''}_recover_public_key_from_signature_`,
-        [messageArray, sig.r, sig.s, sig.v],
-        [64],
-      );
-    return Buffer.from(result);
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response =
+      this.curve === 'secp256r1'
+        ? api.ecdsaSecp256r1RecoverPublicKey({ message: msg, r: sig.r, s: sig.s, v: sig.v[0] })
+        : api.ecdsaSecp256k1RecoverPublicKey({ message: msg, r: sig.r, s: sig.s, v: sig.v[0] });
+    return Buffer.concat([Buffer.from(response.publicKey.x), Buffer.from(response.publicKey.y)]);
   }
 
   /**
@@ -71,15 +65,24 @@ export class Ecdsa {
    * @returns True or false.
    */
   public async verifySignature(msg: Uint8Array, pubKey: Buffer, sig: EcdsaSignature) {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const messageArray = concatenateUint8Arrays([numToInt32BE(msg.length), msg]);
-    const [result] = api
-      .getWasm()
-      .callWasmExport(
-        `ecdsa_${this.curve === 'secp256r1' ? 'r' : ''}_verify_signature_`,
-        [messageArray, pubKey, sig.r, sig.s, sig.v],
-        [1],
-      );
-    return result[0] === 1;
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response =
+      this.curve === 'secp256r1'
+        ? api.ecdsaSecp256r1VerifySignature({
+            message: msg,
+            publicKey: { x: pubKey.subarray(0, 32), y: pubKey.subarray(32, 64) },
+            r: sig.r,
+            s: sig.s,
+            v: sig.v[0],
+          })
+        : api.ecdsaSecp256k1VerifySignature({
+            message: msg,
+            publicKey: { x: pubKey.subarray(0, 32), y: pubKey.subarray(32, 64) },
+            r: sig.r,
+            s: sig.s,
+            v: sig.v[0],
+          });
+    return response.verified;
   }
 }

package/src/crypto/grumpkin/index.ts

@@ -28,9 +28,13 @@ export class Grumpkin {
    * @returns Result of the multiplication.
    */
   public async mul(point: Point, scalar: GrumpkinScalar): Promise<Point> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api.getWasm().callWasmExport('ecc_grumpkin__mul', [point.toBuffer(), scalar.toBuffer()], [64]);
-    return Point.fromBuffer(Buffer.from(result));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.grumpkinMul({
+      point: { x: point.x.toBuffer(), y: point.y.toBuffer() },
+      scalar: scalar.toBuffer(),
+    });
+    return Point.fromBuffer(Buffer.concat([Buffer.from(response.point.x), Buffer.from(response.point.y)]));
   }
 
   /**
@@ -40,9 +44,13 @@ export class Grumpkin {
    * @returns Result of the addition.
    */
   public async add(a: Point, b: Point): Promise<Point> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api.getWasm().callWasmExport('ecc_grumpkin__add', [a.toBuffer(), b.toBuffer()], [64]);
-    return Point.fromBuffer(Buffer.from(result));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.grumpkinAdd({
+      pointA: { x: a.x.toBuffer(), y: a.y.toBuffer() },
+      pointB: { x: b.x.toBuffer(), y: b.y.toBuffer() },
+    });
+    return Point.fromBuffer(Buffer.concat([Buffer.from(response.point.x), Buffer.from(response.point.y)]));
   }
 
   /**
@@ -52,24 +60,14 @@ export class Grumpkin {
    * @returns Points multiplied by the scalar.
    */
   public async batchMul(points: Point[], scalar: GrumpkinScalar) {
-    const concatenatedPoints: Buffer = Buffer.concat(points.map(point => point.toBuffer()));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.grumpkinBatchMul({
+      points: points.map(p => ({ x: p.x.toBuffer(), y: p.y.toBuffer() })),
+      scalar: scalar.toBuffer(),
+    });
 
-    const pointsByteLength = points.length * Point.SIZE_IN_BYTES;
-
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api
-      .getWasm()
-      .callWasmExport(
-        'ecc_grumpkin__batch_mul',
-        [concatenatedPoints, scalar.toBuffer(), points.length],
-        [pointsByteLength],
-      );
-
-    const parsedResult: Point[] = [];
-    for (let i = 0; i < pointsByteLength; i += 64) {
-      parsedResult.push(Point.fromBuffer(Buffer.from(result.subarray(i, i + 64))));
-    }
-    return parsedResult;
+    return response.points.map(p => Point.fromBuffer(Buffer.concat([Buffer.from(p.x), Buffer.from(p.y)])));
   }
 
   /**
@@ -77,9 +75,10 @@ export class Grumpkin {
    * @returns Random field element.
    */
   public async getRandomFr(): Promise<Fr> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api.getWasm().callWasmExport('ecc_grumpkin__get_random_scalar_mod_circuit_modulus', [], [32]);
-    return Fr.fromBuffer(Buffer.from(result));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.grumpkinGetRandomFr({ dummy: 0 });
+    return Fr.fromBuffer(Buffer.from(response.value));
   }
 
   /**
@@ -88,10 +87,9 @@ export class Grumpkin {
    * @returns Buffer representation of the field element.
    */
   public async reduce512BufferToFr(uint512Buf: Buffer): Promise<Fr> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api
-      .getWasm()
-      .callWasmExport('ecc_grumpkin__reduce512_buffer_mod_circuit_modulus', [uint512Buf], [32]);
-    return Fr.fromBuffer(Buffer.from(result));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.grumpkinReduce512({ input: uint512Buf });
+    return Fr.fromBuffer(Buffer.from(response.value));
   }
 }

package/src/crypto/keys/index.ts

@@ -1,10 +1,10 @@
-import { BarretenbergSync, RawBuffer } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { Fr } from '../../fields/fields.js';
 
 export async function vkAsFieldsMegaHonk(input: Buffer): Promise<Fr[]> {
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const result = api.acirVkAsFieldsMegaHonk(new RawBuffer(input));
-
-  return result.map(bbFr => Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  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,4 +1,4 @@
-import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { Fr } from '../../fields/fields.js';
 import { type Fieldable, serializeToFields } from '../../serialize/serialize.js';
@@ -12,14 +12,13 @@ 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));
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const point = api.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())];
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  const api = BarretenbergSync.getSingleton();
+  const response = api.pedersenCommit({
+    inputs: input,
+    hashIndex: offset,
+  });
+  return [Buffer.from(response.point.x), Buffer.from(response.point.y)];
 }
 
 /**
@@ -30,19 +29,24 @@ export async function pedersenCommit(input: Buffer[], offset = 0) {
  */
 export async function pedersenHash(input: Fieldable[], index = 0): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const hash = api.pedersenHash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-    index,
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  const api = BarretenbergSync.getSingleton();
+  const response = api.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 async function pedersenHashBuffer(input: Buffer, index = 0) {
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const result = api.pedersenHashBuffer(input, index);
-  return Buffer.from(result.toBuffer());
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  const api = BarretenbergSync.getSingleton();
+  const response = api.pedersenHashBuffer({
+    input,
+    hashIndex: index,
+  });
+  return Buffer.from(response.hash);
 }

package/src/crypto/poseidon/index.ts

@@ -1,4 +1,4 @@
-import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { Fr } from '../../fields/fields.js';
 import { type Fieldable, serializeToFields } from '../../serialize/serialize.js';
@@ -10,11 +10,12 @@ import { type Fieldable, serializeToFields } from '../../serialize/serialize.js'
  */
 export async function poseidon2Hash(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const hash = api.poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 /**
@@ -26,19 +27,22 @@ 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));
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-
-  const hash = api.poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
-  return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2Hash({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 export async function poseidon2HashAccumulate(input: Fieldable[]): Promise<Fr> {
   const inputFields = serializeToFields(input);
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const result = api.poseidon2HashAccumulate(inputFields.map(i => new FrBarretenberg(i.toBuffer())));
-  return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  const api = BarretenbergSync.getSingleton();
+  const response = api.poseidon2HashAccumulate({
+    inputs: inputFields.map(i => i.toBuffer()),
+  });
+  return Fr.fromBuffer(Buffer.from(response.hash));
 }
 
 /**
@@ -50,11 +54,14 @@ 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');
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const res = api.poseidon2Permutation(inputFields.map(i => new FrBarretenberg(i.toBuffer())));
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  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 async function poseidon2HashBytes(input: Buffer): Promise<Fr> {
@@ -68,10 +75,11 @@ export async function poseidon2HashBytes(input: Buffer): Promise<Fr> {
     inputFields.push(Fr.fromBuffer(fieldBytes));
   }
 
-  const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-  const res = api.poseidon2Hash(
-    inputFields.map(i => new FrBarretenberg(i.toBuffer())), // TODO(#4189): remove this stupid conversion
-  );
+  await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+  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/crypto/schnorr/index.ts

@@ -1,8 +1,6 @@
 import { BarretenbergSync } from '@aztec/bb.js';
 import { type GrumpkinScalar, Point } from '@aztec/foundation/fields';
-import { numToInt32BE } from '@aztec/foundation/serialize';
 
-import { concatenateUint8Arrays } from '../serialize.js';
 import { SchnorrSignature } from './signature.js';
 
 export * from './signature.js';
@@ -17,9 +15,10 @@ export class Schnorr {
    * @returns A grumpkin public key.
    */
   public async computePublicKey(privateKey: GrumpkinScalar): Promise<Point> {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api.getWasm().callWasmExport('schnorr_compute_public_key', [privateKey.toBuffer()], [64]);
-    return Point.fromBuffer(Buffer.from(result));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.schnorrComputePublicKey({ privateKey: privateKey.toBuffer() });
+    return Point.fromBuffer(Buffer.concat([Buffer.from(response.publicKey.x), Buffer.from(response.publicKey.y)]));
   }
 
   /**
@@ -29,12 +28,13 @@ export class Schnorr {
    * @returns A Schnorr signature of the form (s, e).
    */
   public async constructSignature(msg: Uint8Array, privateKey: GrumpkinScalar) {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const messageArray = concatenateUint8Arrays([numToInt32BE(msg.length), msg]);
-    const [s, e] = api
-      .getWasm()
-      .callWasmExport('schnorr_construct_signature', [messageArray, privateKey.toBuffer()], [32, 32]);
-    return new SchnorrSignature(Buffer.from([...s, ...e]));
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.schnorrConstructSignature({
+      message: msg,
+      privateKey: privateKey.toBuffer(),
+    });
+    return new SchnorrSignature(Buffer.from([...response.s, ...response.e]));
   }
 
   /**
@@ -45,11 +45,14 @@ export class Schnorr {
    * @returns True or false.
    */
   public async verifySignature(msg: Uint8Array, pubKey: Point, sig: SchnorrSignature) {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const messageArray = concatenateUint8Arrays([numToInt32BE(msg.length), msg]);
-    const [result] = api
-      .getWasm()
-      .callWasmExport('schnorr_verify_signature', [messageArray, pubKey.toBuffer(), sig.s, sig.e], [1]);
-    return result[0] === 1;
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.schnorrVerifySignature({
+      message: msg,
+      publicKey: { x: pubKey.x.toBuffer(), y: pubKey.y.toBuffer() },
+      s: sig.s,
+      e: sig.e,
+    });
+    return response.verified;
   }
 }

package/src/crypto/secp256k1/index.ts

@@ -27,9 +27,13 @@ export class Secp256k1 {
    * @returns Result of the multiplication.
    */
   public async mul(point: Uint8Array, scalar: Uint8Array) {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api.getWasm().callWasmExport('ecc_secp256k1__mul', [point, scalar], [64]);
-    return Buffer.from(result);
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.secp256k1Mul({
+      point: { x: point.subarray(0, 32), y: point.subarray(32, 64) },
+      scalar,
+    });
+    return Buffer.concat([Buffer.from(response.point.x), Buffer.from(response.point.y)]);
   }
 
   /**
@@ -37,9 +41,10 @@ export class Secp256k1 {
    * @returns Random field element.
    */
   public async getRandomFr() {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api.getWasm().callWasmExport('ecc_secp256k1__get_random_scalar_mod_circuit_modulus', [], [32]);
-    return Buffer.from(result);
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.secp256k1GetRandomFr({ dummy: 0 });
+    return Buffer.from(response.value);
   }
 
   /**
@@ -48,10 +53,9 @@ export class Secp256k1 {
    * @returns Buffer representation of the field element.
    */
   public async reduce512BufferToFr(uint512Buf: Buffer) {
-    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
-    const [result] = api
-      .getWasm()
-      .callWasmExport('ecc_secp256k1__reduce512_buffer_mod_circuit_modulus', [uint512Buf], [32]);
-    return Buffer.from(result);
+    await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });
+    const api = BarretenbergSync.getSingleton();
+    const response = api.secp256k1Reduce512({ input: uint512Buf });
+    return Buffer.from(response.value);
   }
 }

package/src/crypto/secp256k1-signer/utils.ts

@@ -47,6 +47,7 @@ export function addressFromPrivateKey(privateKey: Buffer): EthAddress {
  * @param hash - The hash to recover the address from.
  * @param signature - The signature to recover the address from.
  * @returns The address.
+ * @throws Error if signature recovery fails.
  */
 export function recoverAddress(hash: Buffer32, signature: Signature): EthAddress {
   try {
@@ -59,6 +60,21 @@ export function recoverAddress(hash: Buffer32, signature: Signature): EthAddress
   }
 }
 
+/**
+ * Safely attempts to recover an address from a hash and a signature.
+ * @param hash - The hash to recover the address from.
+ * @param signature - The signature to recover the address from.
+ * @returns The address if recovery succeeds, undefined otherwise.
+ */
+export function tryRecoverAddress(hash: Buffer32, signature: Signature): EthAddress | undefined {
+  try {
+    const publicKey = recoverPublicKey(hash, signature);
+    return publicKeyToAddress(publicKey);
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * @attribution - viem
  * Converts a yParityOrV value to a recovery bit.

package/src/crypto/sync/index.ts

@@ -3,4 +3,4 @@ import { BarretenbergSync } from '@aztec/bb.js';
 export * from './poseidon/index.js';
 export * from './pedersen/index.js';
 
-await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+await BarretenbergSync.initSingleton({ wasmPath: process.env.BB_WASM_PATH });

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

@@ -1,4 +1,4 @@
-import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { BarretenbergSync } from '@aztec/bb.js';
 
 import { Fr } from '../../../fields/fields.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);
 }