@aztec/foundation 0.0.0-test.1 → 0.0.1-commit.b655e406

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/random/index.ts

@@ -1,52 +1,14 @@
-import nodeCrypto from 'crypto';
-import isNode from 'detect-node';
+import { randomBytes as bbRandomBytes } from '@aztec/bb.js';
 
 import { RandomnessSingleton } from './randomness_singleton.js';
 
-// limit of Crypto.getRandomValues()
-// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
-const MAX_BYTES = 65536;
-
-const getWebCrypto = () => {
-  if (typeof window !== 'undefined' && window.crypto) {
-    return window.crypto;
-  }
-  if (typeof self !== 'undefined' && self.crypto) {
-    return self.crypto;
-  }
-  return undefined;
-};
-
 export const randomBytes = (len: number) => {
   const singleton = RandomnessSingleton.getInstance();
 
   if (singleton.isDeterministic()) {
     return singleton.getBytes(len);
   }
-
-  if (isNode) {
-    return nodeCrypto.randomBytes(len) as Buffer;
-  }
-
-  const crypto = getWebCrypto();
-  if (!crypto) {
-    throw new Error('randomBytes UnsupportedEnvironment');
-  }
-
-  const buf = Buffer.allocUnsafe(len);
-  if (len > MAX_BYTES) {
-    // this is the max bytes crypto.getRandomValues
-    // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
-    for (let generated = 0; generated < len; generated += MAX_BYTES) {
-      // buffer.slice automatically checks if the end is past the end of
-      // the buffer so we don't have to here
-      crypto.getRandomValues(buf.slice(generated, generated + MAX_BYTES));
-    }
-  } else {
-    crypto.getRandomValues(buf);
-  }
-
-  return buf;
+  return Buffer.from(bbRandomBytes(len)) as Buffer<ArrayBuffer>;
 };
 
 /**

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

@@ -7,6 +7,27 @@ import { keccak256 } from '../keccak/index.js';
 
 const ETH_SIGN_PREFIX = '\x19Ethereum Signed Message:\n32';
 
+/** Signature recovery options */
+type RecoveryOpts = {
+  /**
+   * Whether to allow s-values in the high half of the curve (s >= CURVE.n/2).
+   * These are discouraged by EIP2 to prevent signature malleability, and outright
+   * rejected in OpenZeppelin's ECDSA recover, which we use in our Rollup contract.
+   */
+  allowMalleable?: boolean;
+  /**
+   * Whether to allow an y-parity 0-1 bit instead of the standard v value 27-28.
+   */
+  allowYParityAsV?: boolean;
+};
+
+export class Secp256k1Error extends Error {
+  constructor(message: string, opts?: { cause: unknown }) {
+    super(message, opts);
+    this.name = 'Secp256k1Error';
+  }
+}
+
 // We just hash the message to make it easier to work with in the smart contract.
 export function makeEthSignDigest(message: Buffer32): Buffer32 {
   const prefix = Buffer.from(ETH_SIGN_PREFIX);
@@ -46,11 +67,36 @@ export function addressFromPrivateKey(privateKey: Buffer): EthAddress {
  * Recovers 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.
+ * @param opts - Recovery options.
  * @returns The address.
+ * @throws Error if signature recovery fails or if signature is malleable and allowMalleable is false.
  */
-export function recoverAddress(hash: Buffer32, signature: Signature): EthAddress {
-  const publicKey = recoverPublicKey(hash, signature);
-  return publicKeyToAddress(publicKey);
+export function recoverAddress(hash: Buffer32, signature: Signature, opts?: RecoveryOpts): EthAddress {
+  try {
+    const publicKey = recoverPublicKey(hash, signature, opts);
+    return publicKeyToAddress(publicKey);
+  } catch (err: unknown) {
+    throw new Secp256k1Error(
+      `Error recovering Ethereum address from hash ${hash.toString()} and signature ${signature.toString()}`,
+      { cause: err },
+    );
+  }
+}
+
+/**
+ * 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.
+ * @param opts - Recovery options.
+ * @returns The address if recovery succeeds, undefined otherwise.
+ */
+export function tryRecoverAddress(hash: Buffer32, signature: Signature, opts?: RecoveryOpts): EthAddress | undefined {
+  try {
+    const publicKey = recoverPublicKey(hash, signature, opts);
+    return publicKeyToAddress(publicKey);
+  } catch {
+    return undefined;
+  }
 }
 
 /**
@@ -59,7 +105,7 @@ export function recoverAddress(hash: Buffer32, signature: Signature): EthAddress
  * @param yParityOrV - The yParityOrV value to convert.
  * @returns The recovery bit.
  */
-function toRecoveryBit(yParityOrV: number) {
+export function toRecoveryBit(yParityOrV: number) {
   if (yParityOrV === 0 || yParityOrV === 1) {
     return yParityOrV;
   }
@@ -69,7 +115,7 @@ function toRecoveryBit(yParityOrV: number) {
   if (yParityOrV === 28) {
     return 1;
   }
-  throw new Error('Invalid yParityOrV value');
+  throw new Secp256k1Error(`Invalid yParityOrV value ${yParityOrV}`);
 }
 
 /**
@@ -83,17 +129,84 @@ export function signMessage(message: Buffer32, privateKey: Buffer) {
   return new Signature(Buffer32.fromBigInt(r), Buffer32.fromBigInt(s), recovery ? 28 : 27);
 }
 
+/**
+ * Flips an ECDSA signature.
+ * If the signature has a low s-value (s < CURVE.n/2), it flips it to high s-value (CURVE.n - s) and vice versa.
+ * Also flips the v value accordingly (27 <-> 28, or 0 <-> 1).
+ * This is useful for testing signature malleability handling.
+ * @param signature - The signature to flip.
+ * @returns A new signature with flipped s-value and v-value.
+ */
+export function flipSignature(signature: Signature): Signature {
+  const { r, s, v } = signature;
+  const sig = new secp256k1.Signature(r.toBigInt(), s.toBigInt());
+  const flippedS = secp256k1.CURVE.n - sig.s;
+
+  return new Signature(r, Buffer32.fromBigInt(flippedS), flipV(v));
+}
+
+/**
+ * Normalizes an ECDSA signature.
+ * If the signature has a high s-value (s >= CURVE.n/2), it flips it to low s-value (CURVE.n - s), and flips v accordingly.
+ * If the signature uses a recovery bit of 0/1, it is converted to a v-value 27/28 for ecrecover.
+ * @remarks This does not handle post EIP155 tx signatures which embed the chain id in v. Use it only for feeding into ECRECOVER precompiles.
+ * @param signature - The signature to normalize.
+ */
+export function normalizeSignature(signature: Signature): Signature {
+  const { r, s, v } = signature;
+  const sig = new secp256k1.Signature(r.toBigInt(), s.toBigInt());
+  if (sig.hasHighS()) {
+    const newV = flipV(v);
+    const newS = sig.normalizeS().s;
+    return new Signature(r, Buffer32.fromBigInt(newS), toVFromYParityOrV(newV));
+  }
+
+  return new Signature(r, s, toVFromYParityOrV(v));
+}
+
+/** Converts a yParityOrV value to a pre-EIP155 v-value 27-28. */
+function toVFromYParityOrV(yParityOrV: number): number {
+  if (yParityOrV === 0 || yParityOrV === 1) {
+    return yParityOrV + 27;
+  } else if (yParityOrV === 27 || yParityOrV === 28) {
+    return yParityOrV;
+  } else {
+    throw new Secp256k1Error(`Invalid yParityOrV value ${yParityOrV}`);
+  }
+}
+
+/** Flips the recovery bit or v-value */
+function flipV(v: number): number {
+  switch (v) {
+    case 27:
+      return 28;
+    case 28:
+      return 27;
+    case 0:
+      return 1;
+    case 1:
+      return 0;
+    default:
+      throw new Secp256k1Error(`Invalid v value ${v}`);
+  }
+}
+
 /**
  * Recovers a public key from a hash and a signature.
  * @param hash - The hash to recover the public key from.
  * @param signature - The signature to recover the public key from.
  * @returns The public key.
  */
-export function recoverPublicKey(hash: Buffer32, signature: Signature): Buffer {
+export function recoverPublicKey(hash: Buffer32, signature: Signature, opts: RecoveryOpts = {}): Buffer {
   const { r, s, v } = signature;
+  if (!opts.allowYParityAsV && v !== 27 && v !== 28) {
+    throw new Secp256k1Error(`Invalid v value ${v} (expected 27 or 28)`);
+  }
   const recoveryBit = toRecoveryBit(v);
   const sig = new secp256k1.Signature(r.toBigInt(), s.toBigInt()).addRecoveryBit(recoveryBit);
-
+  if (!opts.allowMalleable && sig.hasHighS()) {
+    throw new Secp256k1Error('Signature has high s-value (malleable signature)');
+  }
   const publicKey = sig.recoverPublicKey(hash.buffer).toHex(false);
   return Buffer.from(publicKey, 'hex');
 }

package/src/crypto/sha256/index.ts

@@ -4,6 +4,7 @@ import { default as hash } from 'hash.js';
 import { Fr } from '../../fields/fields.js';
 import { truncateAndPad } from '../../serialize/free_funcs.js';
 import { type Bufferable, serializeToBuffer } from '../../serialize/serialize.js';
+import type { Hasher } from '../../trees/hasher.js';
 
 export function sha256(data: Buffer) {
   return Buffer.from(hash.sha256().update(data).digest());
@@ -145,3 +146,49 @@ function g0_256(x: number) {
 function g1_256(x: number) {
   return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);
 }
+
+/**
+ * A helper class encapsulating SHA256 hash functionality.
+ * @deprecated Don't call SHA256 directly in production code. Instead, create suitably-named functions for specific
+ * purposes.
+ */
+export class SHA256 implements Hasher {
+  /*
+   * @deprecated Don't call SHA256 directly in production code. Instead, create suitably-named functions for specific
+   * purposes.
+   */
+  public hash(lhs: Uint8Array, rhs: Uint8Array) {
+    return sha256(Buffer.concat([Buffer.from(lhs), Buffer.from(rhs)])) as Buffer<ArrayBuffer>;
+  }
+
+  /*
+   * @deprecated Don't call SHA256 directly in production code. Instead, create suitably-named functions for specific
+   * purposes.
+   */
+  public hashInputs(inputs: Buffer[]) {
+    return sha256(Buffer.concat(inputs)) as Buffer<ArrayBuffer>;
+  }
+}
+
+/**
+ * A helper class encapsulating truncated SHA256 hash functionality.
+ * @deprecated Don't call SHA256 directly in production code. Instead, create suitably-named functions for specific
+ * purposes.
+ */
+export class SHA256Trunc implements Hasher {
+  /*
+   * @deprecated Don't call SHA256 directly in production code. Instead, create suitably-named functions for specific
+   * purposes.
+   */
+  public hash(lhs: Uint8Array, rhs: Uint8Array) {
+    return truncateAndPad(sha256(Buffer.concat([Buffer.from(lhs), Buffer.from(rhs)]))) as Buffer<ArrayBuffer>;
+  }
+
+  /*
+   * @deprecated Don't call SHA256 directly in production code. Instead, create suitably-named functions for specific
+   * purposes.
+   */
+  public hashInputs(inputs: Buffer[]) {
+    return truncateAndPad(sha256(Buffer.concat(inputs))) as Buffer<ArrayBuffer>;
+  }
+}

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);
 }

package/src/crypto/sync/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,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/eth-address/index.ts

@@ -117,14 +117,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.
@@ -228,6 +228,13 @@ export class EthAddress {
     return new EthAddress(reader.readBytes(EthAddress.SIZE_IN_BYTES));
   }
 
+  /** Converts a number into an address. Useful for testing. */
+  static fromNumber(num: bigint | number): EthAddress {
+    const buffer = Buffer.alloc(EthAddress.SIZE_IN_BYTES);
+    buffer.writeBigUInt64BE(BigInt(num), 0);
+    return new EthAddress(buffer);
+  }
+
   toJSON() {
     return this.toString();
   }