@aztec/bb.js 0.0.0-devnet → 0.0.0-test.1

package/src/main.ts

@@ -22,18 +22,18 @@ const debug = createDebug('bb.js');
 const MAX_ULTRAPLONK_CIRCUIT_SIZE_IN_WASM = 2 ** 19;
 const threads = +process.env.HARDWARE_CONCURRENCY! || undefined;
 
-function getBytecode(bytecodePath: string) {
+function getBytecode(bytecodePath: string): Uint8Array {
   const extension = bytecodePath.substring(bytecodePath.lastIndexOf('.') + 1);
 
   if (extension == 'json') {
     const encodedCircuit = JSON.parse(readFileSync(bytecodePath, 'utf8'));
     const decompressed = gunzipSync(Buffer.from(encodedCircuit.bytecode, 'base64'));
-    return decompressed;
+    return Uint8Array.from(decompressed);
   }
 
   const encodedCircuit = readFileSync(bytecodePath);
   const decompressed = gunzipSync(encodedCircuit);
-  return decompressed;
+  return Uint8Array.from(decompressed);
 }
 
 function base64ToUint8Array(base64: string) {
@@ -62,14 +62,14 @@ async function getGatesUltra(bytecodePath: string, recursive: boolean, honkRecur
   return total;
 }
 
-function getWitness(witnessPath: string) {
+function getWitness(witnessPath: string): Uint8Array {
   const data = readFileSync(witnessPath);
   const decompressed = gunzipSync(data);
-  return decompressed;
+  return Uint8Array.from(decompressed);
 }
 
 async function computeCircuitSize(bytecodePath: string, recursive: boolean, honkRecursion: boolean, api: Barretenberg) {
-  debug(`computing circuit size...`);
+  debug(`Computing circuit size for ${bytecodePath}`);
   const bytecode = getBytecode(bytecodePath);
   const [total, subgroup] = await api.acirGetCircuitSizes(bytecode, recursive, honkRecursion);
   return { total, subgroup };
@@ -84,6 +84,7 @@ async function initUltraPlonk(
 ) {
   const api = await Barretenberg.new({ threads });
 
+  // TODO(https://github.com/AztecProtocol/barretenberg/issues/1248): Get rid of this call to avoid building the circuit twice.
   // TODO(https://github.com/AztecProtocol/barretenberg/issues/1126): use specific UltraPlonk function
   const circuitSize = await getGatesUltra(bytecodePath, recursive, honkRecursion, api);
   // TODO(https://github.com/AztecProtocol/barretenberg/issues/811): remove subgroupSizeOverride hack for goblin
@@ -92,9 +93,7 @@ async function initUltraPlonk(
   if (subgroupSize > MAX_ULTRAPLONK_CIRCUIT_SIZE_IN_WASM) {
     throw new Error(`Circuit size of ${subgroupSize} exceeds max supported of ${MAX_ULTRAPLONK_CIRCUIT_SIZE_IN_WASM}`);
   }
-  debug(`circuit size: ${circuitSize}`);
-  debug(`subgroup size: ${subgroupSize}`);
-  debug('loading crs...');
+  debug(`Loading CRS for UltraPlonk with circuit-size=${circuitSize} subgroup-size=${subgroupSize}`);
   // Plus 1 needed! (Move +1 into Crs?)
   const crs = await Crs.new(subgroupSize + 1, crsPath);
 
@@ -112,14 +111,13 @@ async function initUltraPlonk(
 async function initUltraHonk(bytecodePath: string, recursive: boolean, crsPath: string) {
   const api = await Barretenberg.new({ threads });
 
+  // TODO(https://github.com/AztecProtocol/barretenberg/issues/1248): Get rid of this call to avoid building the circuit twice.
   // TODO(https://github.com/AztecProtocol/barretenberg/issues/1126): use specific UltraHonk function
   const circuitSize = await getGatesUltra(bytecodePath, recursive, /*honkRecursion=*/ true, api);
   // TODO(https://github.com/AztecProtocol/barretenberg/issues/811): remove subgroupSizeOverride hack for goblin
   const dyadicCircuitSize = Math.pow(2, Math.ceil(Math.log2(circuitSize)));
 
-  debug(`circuit size: ${circuitSize}`);
-  debug(`dyadic circuit size size: ${dyadicCircuitSize}`);
-  debug('loading crs...');
+  debug(`Loading CRS for UltraHonk with circuit-size=${circuitSize} dyadic-circuit-size=${dyadicCircuitSize}`);
   const crs = await Crs.new(dyadicCircuitSize + 1, crsPath);
 
   // Load CRS into wasm global CRS state.
@@ -131,7 +129,7 @@ async function initUltraHonk(bytecodePath: string, recursive: boolean, crsPath:
 async function initClientIVC(crsPath: string) {
   const api = await Barretenberg.new({ threads });
 
-  debug('loading BN254 and Grumpkin crs...');
+  debug('Loading CRS for ClientIVC');
   const crs = await Crs.new(2 ** 21 + 1, crsPath);
   const grumpkinCrs = await GrumpkinCrs.new(2 ** 16 + 1, crsPath);
 
@@ -161,7 +159,7 @@ export async function proveAndVerify(bytecodePath: string, recursive: boolean, w
 
   const { api, acirComposer, circuitSize, subgroupSize } = await initUltraPlonk(bytecodePath, recursive, crsPath);
   try {
-    debug(`creating proof...`);
+    debug(`Creating proof bytecode=${bytecodePath} witness=${witnessPath} recursive=${recursive}`);
     const bytecode = getBytecode(bytecodePath);
     const witness = getWitness(witnessPath);
 
@@ -175,9 +173,9 @@ export async function proveAndVerify(bytecodePath: string, recursive: boolean, w
     const proof = await api.acirCreateProof(acirComposer, bytecode, recursive, witness);
     writeBenchmark('proof_construction_time', proofTimer.ms(), { acir_test, threads });
 
-    debug(`verifying...`);
+    debug(`Proof complete. Verifying.`);
     const verified = await api.acirVerifyProof(acirComposer, proof);
-    debug(`verified: ${verified}`);
+    debug(`Verification ${verified ? 'successful' : 'failed'}`);
     return verified;
   } finally {
     await api.destroy();
@@ -233,7 +231,7 @@ export async function proveAndVerifyAztecClient(bytecodePath: string, witnessPat
     const witness = readStack(witnessPath);
 
     const verified = await api.acirProveAndVerifyAztecClient(bytecode, witness);
-    console.log(`verified?: ${verified}`);
+    debug(`Verification ${verified ? 'successful' : 'failed'}`);
     return verified;
   } finally {
     await api.destroy();
@@ -254,7 +252,7 @@ export async function foldAndVerifyProgram(
     const witness = getWitness(witnessPath);
 
     const verified = await api.acirFoldAndVerifyProgramStack(bytecode, recursive, witness);
-    debug(`verified: ${verified}`);
+    debug(`Verification ${verified ? 'successful' : 'failed'}`);
     return verified;
   } finally {
     await api.destroy();
@@ -271,18 +269,17 @@ export async function prove(
 ) {
   const { api, acirComposer } = await initUltraPlonk(bytecodePath, recursive, crsPath);
   try {
-    debug(`creating proof...`);
+    debug(`Creating proof bytecode=${bytecodePath} witness=${witnessPath} recursive=${recursive}`);
     const bytecode = getBytecode(bytecodePath);
     const witness = getWitness(witnessPath);
     const proof = await api.acirCreateProof(acirComposer, bytecode, recursive, witness);
-    debug(`done.`);
 
     if (outputPath === '-') {
       process.stdout.write(proof);
-      debug(`proof written to stdout`);
+      debug(`Proof written to stdout`);
     } else {
       writeFileSync(outputPath, proof);
-      debug(`proof written to: ${outputPath}`);
+      debug(`Proof written to ${outputPath}`);
     }
   } finally {
     await api.destroy();
@@ -293,14 +290,14 @@ export async function gateCountUltra(bytecodePath: string, recursive: boolean, h
   const api = await Barretenberg.new({ threads: 1 });
   try {
     const numberOfGates = await getGatesUltra(bytecodePath, recursive, honkRecursion, api);
-    debug(`number of gates: : ${numberOfGates}`);
+    debug(`Number of gates: ${numberOfGates}`);
     // Create an 8-byte buffer and write the number into it.
     // Writing number directly to stdout will result in a variable sized
     // input depending on the size.
     const buffer = Buffer.alloc(8);
     buffer.writeBigInt64LE(BigInt(numberOfGates));
 
-    process.stdout.write(buffer);
+    process.stdout.write(Uint8Array.from(buffer));
   } finally {
     await api.destroy();
   }
@@ -310,8 +307,8 @@ export async function verify(proofPath: string, vkPath: string, crsPath: string)
   const { api, acirComposer } = await initLite(crsPath);
   try {
     await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
-    const verified = await api.acirVerifyProof(acirComposer, readFileSync(proofPath));
-    debug(`verified: ${verified}`);
+    const verified = await api.acirVerifyProof(acirComposer, Uint8Array.from(readFileSync(proofPath)));
+    debug(`Verification ${verified ? 'successful' : 'failed'}`);
     return verified;
   } finally {
     await api.destroy();
@@ -321,15 +318,16 @@ export async function verify(proofPath: string, vkPath: string, crsPath: string)
 export async function contract(outputPath: string, vkPath: string, crsPath: string) {
   const { api, acirComposer } = await initLite(crsPath);
   try {
+    debug(`Creating verifier contract vk=${vkPath}`);
     await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
     const contract = await api.acirGetSolidityVerifier(acirComposer);
 
     if (outputPath === '-') {
       process.stdout.write(contract);
-      debug(`contract written to stdout`);
+      debug(`Solidity verifier contract written to stdout`);
     } else {
       writeFileSync(outputPath, contract);
-      debug(`contract written to: ${outputPath}`);
+      debug(`Solidity verifier contract written to ${outputPath}`);
     }
   } finally {
     await api.destroy();
@@ -339,18 +337,17 @@ export async function contract(outputPath: string, vkPath: string, crsPath: stri
 export async function contractUltraHonk(bytecodePath: string, vkPath: string, crsPath: string, outputPath: string) {
   const { api } = await initUltraHonk(bytecodePath, false, crsPath);
   try {
-    console.log('bytecodePath', bytecodePath);
+    debug(`Creating UltraHonk verifier contract bytecode=${bytecodePath} vk=${vkPath}`);
     const bytecode = getBytecode(bytecodePath);
-    console.log('vkPath', vkPath);
     const vk = new RawBuffer(readFileSync(vkPath));
     const contract = await api.acirHonkSolidityVerifier(bytecode, vk);
 
     if (outputPath === '-') {
       process.stdout.write(contract);
-      debug(`contract written to stdout`);
+      debug(`Solidity verifier contract written to stdout`);
     } else {
       writeFileSync(outputPath, contract);
-      debug(`contract written to: ${outputPath}`);
+      debug(`Solidity verifier contract written to ${outputPath}`);
     }
   } finally {
     await api.destroy();
@@ -360,19 +357,19 @@ export async function contractUltraHonk(bytecodePath: string, vkPath: string, cr
 export async function writeVk(bytecodePath: string, recursive: boolean, crsPath: string, outputPath: string) {
   const { api, acirComposer } = await initUltraPlonk(bytecodePath, recursive, crsPath);
   try {
-    debug('initing proving key...');
+    debug(`Initializing proving key bytecode=${bytecodePath} recursive=${recursive}`);
     const bytecode = getBytecode(bytecodePath);
     await api.acirInitProvingKey(acirComposer, bytecode, recursive);
 
-    debug('initing verification key...');
+    debug(`Initializing verification key`);
     const vk = await api.acirGetVerificationKey(acirComposer);
 
     if (outputPath === '-') {
       process.stdout.write(vk);
-      debug(`vk written to stdout`);
+      debug(`Verification key written to stdout`);
     } else {
       writeFileSync(outputPath, vk);
-      debug(`vk written to: ${outputPath}`);
+      debug(`Verification key written to ${outputPath}`);
     }
   } finally {
     await api.destroy();
@@ -382,16 +379,16 @@ export async function writeVk(bytecodePath: string, recursive: boolean, crsPath:
 export async function writePk(bytecodePath: string, recursive: boolean, crsPath: string, outputPath: string) {
   const { api, acirComposer } = await initUltraPlonk(bytecodePath, recursive, crsPath);
   try {
-    debug('initing proving key...');
+    debug(`Initializing proving key bytecode=${bytecodePath} recursive=${recursive}`);
     const bytecode = getBytecode(bytecodePath);
     const pk = await api.acirGetProvingKey(acirComposer, bytecode, recursive);
 
     if (outputPath === '-') {
       process.stdout.write(pk);
-      debug(`pk written to stdout`);
+      debug(`Proving key written to stdout`);
     } else {
       writeFileSync(outputPath, pk);
-      debug(`pk written to: ${outputPath}`);
+      debug(`Proving key written to ${outputPath}`);
     }
   } finally {
     await api.destroy();
@@ -402,24 +399,22 @@ export async function proofAsFields(proofPath: string, vkPath: string, outputPat
   const { api, acirComposer } = await initLite(crsPath);
 
   try {
-    debug('serializing proof byte array into field elements');
+    debug(`Serializing proof byte array into field elements proof=${proofPath} vk=${vkPath}`);
     const numPublicInputs = readFileSync(vkPath).readUint32BE(8);
     const proofAsFields = await api.acirSerializeProofIntoFields(
       acirComposer,
-      readFileSync(proofPath),
+      Uint8Array.from(readFileSync(proofPath)),
       numPublicInputs,
     );
     const jsonProofAsFields = JSON.stringify(proofAsFields.map(f => f.toString()));
 
     if (outputPath === '-') {
       process.stdout.write(jsonProofAsFields);
-      debug(`proofAsFields written to stdout`);
+      debug(`Proof as fields written to stdout`);
     } else {
       writeFileSync(outputPath, jsonProofAsFields);
-      debug(`proofAsFields written to: ${outputPath}`);
+      debug(`Proof as fields written to ${outputPath}`);
     }
-
-    debug('done.');
   } finally {
     await api.destroy();
   }
@@ -429,7 +424,7 @@ export async function vkAsFields(vkPath: string, vkeyOutputPath: string, crsPath
   const { api, acirComposer } = await initLite(crsPath);
 
   try {
-    debug('serializing vk byte array into field elements');
+    debug(`Serializing vk byte array into field elements vk=${vkPath}`);
     await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
     const [vkAsFields, vkHash] = await api.acirSerializeVerificationKeyIntoFields(acirComposer);
     const output = [vkHash, ...vkAsFields].map(f => f.toString());
@@ -437,13 +432,11 @@ export async function vkAsFields(vkPath: string, vkeyOutputPath: string, crsPath
 
     if (vkeyOutputPath === '-') {
       process.stdout.write(jsonVKAsFields);
-      debug(`vkAsFields written to stdout`);
+      debug(`Verification key as fields written to stdout`);
     } else {
       writeFileSync(vkeyOutputPath, jsonVKAsFields);
-      debug(`vkAsFields written to: ${vkeyOutputPath}`);
+      debug(`Verification key as fields written to ${vkeyOutputPath}`);
     }
-
-    debug('done.');
   } finally {
     await api.destroy();
   }
@@ -459,7 +452,7 @@ export async function proveUltraHonk(
 ) {
   const { api } = await initUltraHonk(bytecodePath, recursive, crsPath);
   try {
-    debug(`creating proof...`);
+    debug(`Creating UltraHonk proof bytecode=${bytecodePath} recursive=${recursive}`);
     const bytecode = getBytecode(bytecodePath);
     const witness = getWitness(witnessPath);
 
@@ -467,14 +460,13 @@ export async function proveUltraHonk(
       ? api.acirProveUltraKeccakHonk.bind(api)
       : api.acirProveUltraHonk.bind(api);
     const proof = await acirProveUltraHonk(bytecode, recursive, witness);
-    debug(`done.`);
 
     if (outputPath === '-') {
       process.stdout.write(proof);
-      debug(`proof written to stdout`);
+      debug(`Proof written to stdout`);
     } else {
       writeFileSync(outputPath, proof);
-      debug(`proof written to: ${outputPath}`);
+      debug(`Proof written to ${outputPath}`);
     }
   } finally {
     await api.destroy();
@@ -491,7 +483,7 @@ export async function writeVkUltraHonk(
   const { api } = await initUltraHonk(bytecodePath, recursive, crsPath);
   try {
     const bytecode = getBytecode(bytecodePath);
-    debug('initing verification key...');
+    debug(`Initializing UltraHonk verification key bytecode=${bytecodePath} recursive=${recursive}`);
 
     const acirWriteVkUltraHonk = options?.keccak
       ? api.acirWriteVkUltraKeccakHonk.bind(api)
@@ -500,10 +492,10 @@ export async function writeVkUltraHonk(
 
     if (outputPath === '-') {
       process.stdout.write(vk);
-      debug(`vk written to stdout`);
+      debug(`Verification key written to stdout`);
     } else {
       writeFileSync(outputPath, vk);
-      debug(`vk written to: ${outputPath}`);
+      debug(`Verification key written to ${outputPath}`);
     }
   } finally {
     await api.destroy();
@@ -521,9 +513,12 @@ export async function verifyUltraHonk(
     const acirVerifyUltraHonk = options?.keccak
       ? api.acirVerifyUltraKeccakHonk.bind(api)
       : api.acirVerifyUltraHonk.bind(api);
-    const verified = await acirVerifyUltraHonk(readFileSync(proofPath), new RawBuffer(readFileSync(vkPath)));
+    const verified = await acirVerifyUltraHonk(
+      Uint8Array.from(readFileSync(proofPath)),
+      new RawBuffer(readFileSync(vkPath)),
+    );
 
-    debug(`verified: ${verified}`);
+    debug(`Verification ${verified ? 'successful' : 'failed'}`);
     return verified;
   } finally {
     await api.destroy();
@@ -533,19 +528,17 @@ export async function verifyUltraHonk(
 export async function proofAsFieldsUltraHonk(proofPath: string, outputPath: string, crsPath: string) {
   const { api } = await initLite(crsPath);
   try {
-    debug('outputting proof as vector of fields');
-    const proofAsFields = await api.acirProofAsFieldsUltraHonk(readFileSync(proofPath));
+    debug(`Outputting UltraHonk proof as vector of fields proof=${proofPath}`);
+    const proofAsFields = await api.acirProofAsFieldsUltraHonk(Uint8Array.from(readFileSync(proofPath)));
     const jsonProofAsFields = JSON.stringify(proofAsFields.map(f => f.toString()));
 
     if (outputPath === '-') {
       process.stdout.write(jsonProofAsFields);
-      debug(`proofAsFieldsUltraHonk written to stdout`);
+      debug(`Proof as fields written to stdout`);
     } else {
       writeFileSync(outputPath, jsonProofAsFields);
-      debug(`proofAsFieldsUltraHonk written to: ${outputPath}`);
+      debug(`Proof as fields written to ${outputPath}`);
     }
-
-    debug('done.');
   } finally {
     await api.destroy();
   }
@@ -555,19 +548,17 @@ export async function vkAsFieldsUltraHonk(vkPath: string, vkeyOutputPath: string
   const { api } = await initLite(crsPath);
 
   try {
-    debug('serializing vk byte array into field elements');
+    debug(`Serializing vk byte array into field elements vk=${vkPath}`);
     const vkAsFields = await api.acirVkAsFieldsUltraHonk(new RawBuffer(readFileSync(vkPath)));
     const jsonVKAsFields = JSON.stringify(vkAsFields.map(f => f.toString()));
 
     if (vkeyOutputPath === '-') {
       process.stdout.write(jsonVKAsFields);
-      debug(`vkAsFieldsUltraHonk written to stdout`);
+      debug(`Verification key as fields written to stdout`);
     } else {
       writeFileSync(vkeyOutputPath, jsonVKAsFields);
-      debug(`vkAsFieldsUltraHonk written to: ${vkeyOutputPath}`);
+      debug(`Verification key as fields written to ${vkeyOutputPath}`);
     }
-
-    debug('done.');
   } finally {
     await api.destroy();
   }

package/src/proof/index.ts

@@ -9,6 +9,17 @@ export type ProofData = {
   proof: Uint8Array;
 };
 
+/**
+ * @description
+ * The representation of a proof
+ * */
+export type ProofDataForRecursion = {
+  /** @description Public inputs of a proof */
+  publicInputs: string[];
+  /** @description An byte array representing the proof */
+  proof: string[];
+};
+
 // Buffers are prepended with their size. The size takes 4 bytes.
 const serializedBufferSize = 4;
 const fieldByteSize = 32;

package/src/retry/index.ts

@@ -0,0 +1,50 @@
+/**
+ * Generates a backoff sequence for retrying operations with an increasing delay.
+ * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
+ * This generator can be used in combination with the `retry` function to perform
+ * retries with exponential backoff and capped at 64 seconds between attempts.
+ *
+ * @returns A generator that yields the next backoff value in seconds as an integer.
+ */
+export function* backoffGenerator() {
+  const v = [1, 1, 1, 2, 4, 8, 16, 32, 64];
+  let i = 0;
+  while (true) {
+    yield v[Math.min(i++, v.length - 1)];
+  }
+}
+
+/**
+ * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
+ * @param retries - Intervals to retry (in seconds).
+ * @returns A generator sequence.
+ */
+export function* makeBackoff(retries: number[]) {
+  for (const retry of retries) {
+    yield retry;
+  }
+}
+
+/**
+ * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
+ * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
+ *
+ * @param fn - The asynchronous function to be retried.
+ * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
+ * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
+ * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
+ */
+export async function retry<Result>(fn: () => Promise<Result>, backoff = backoffGenerator()) {
+  while (true) {
+    try {
+      return await fn();
+    } catch (err: any) {
+      const s = backoff.next().value;
+      if (s === undefined) {
+        throw err;
+      }
+      await new Promise(resolve => setTimeout(resolve, s * 1000));
+      continue;
+    }
+  }
+}

package/src/types/fields.ts

@@ -1,5 +1,10 @@
 import { randomBytes } from '../random/index.js';
-import { toBigIntBE, toBufferBE } from '../bigint-array/index.js';
+import {
+  buffer32BytesToBigIntBE,
+  uint8ArrayToBigIntBE,
+  bigIntToBufferBE,
+  bigIntToUint8ArrayBE,
+} from '../bigint-array/index.js';
 import { BufferReader, uint8ArrayToHexString } from '../serialize/index.js';
 
 // TODO(#4189): Replace with implementation in yarn-project/foundation/src/fields/fields.ts
@@ -15,30 +20,36 @@ export class Fr {
   static SIZE_IN_BYTES = 32;
   value: Uint8Array;
 
-  constructor(value: Uint8Array | bigint) {
+  constructor(value: Uint8Array | Buffer | bigint) {
     // We convert buffer value to bigint to be able to check it fits within modulus
-    const valueBigInt = typeof value === 'bigint' ? value : toBigIntBE(value);
+    const valueBigInt =
+      typeof value === 'bigint'
+        ? value
+        : value instanceof Buffer
+        ? buffer32BytesToBigIntBE(value)
+        : uint8ArrayToBigIntBE(value);
 
     if (valueBigInt > Fr.MAX_VALUE) {
       throw new Error(`Value 0x${valueBigInt.toString(16)} is greater or equal to field modulus.`);
     }
 
-    this.value = typeof value === 'bigint' ? toBufferBE(value) : value;
+    this.value =
+      typeof value === 'bigint' ? bigIntToUint8ArrayBE(value) : value instanceof Buffer ? new Uint8Array(value) : value;
   }
 
   static random() {
-    const r = toBigIntBE(randomBytes(64)) % Fr.MODULUS;
+    const r = uint8ArrayToBigIntBE(randomBytes(64)) % Fr.MODULUS;
     return new this(r);
   }
 
-  static fromBuffer(buffer: Uint8Array | BufferReader) {
+  static fromBuffer(buffer: Uint8Array | Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new this(reader.readBytes(this.SIZE_IN_BYTES));
   }
 
   static fromBufferReduce(buffer: Uint8Array | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
+    return new this(uint8ArrayToBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
   }
 
   static fromString(str: string) {
@@ -79,18 +90,18 @@ export class Fq {
   }
 
   static random() {
-    const r = toBigIntBE(randomBytes(64)) % Fq.MODULUS;
+    const r = uint8ArrayToBigIntBE(randomBytes(64)) % Fq.MODULUS;
     return new this(r);
   }
 
-  static fromBuffer(buffer: Uint8Array | BufferReader) {
+  static fromBuffer(buffer: Uint8Array | Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)));
+    return new this(uint8ArrayToBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)));
   }
 
-  static fromBufferReduce(buffer: Uint8Array | BufferReader) {
+  static fromBufferReduce(buffer: Uint8Array | Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new this(toBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
+    return new this(uint8ArrayToBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
   }
 
   static fromString(str: string) {
@@ -98,7 +109,7 @@ export class Fq {
   }
 
   toBuffer() {
-    return toBufferBE(this.value, Fq.SIZE_IN_BYTES);
+    return bigIntToBufferBE(this.value, Fq.SIZE_IN_BYTES);
   }
 
   toString() {

package/dest/browser/522.index.js

@@ -1,10 +0,0 @@
-(globalThis["webpackChunk_aztec_bb_js"] = globalThis["webpackChunk_aztec_bb_js"] || []).push([[522],{
-
-/***/ 522:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ })
-
-}])