@aztec/bb.js 0.73.0 → 0.75.0-commit.8a71f57856e217a77b6e50cbc8833c1cd5395b96

package/src/crs/net_crs.ts

@@ -1,3 +1,4 @@
+import { retry, makeBackoff } from '../retry/index.js';
 /**
  * Downloader for CRS from the web or local.
  */
@@ -28,12 +29,16 @@ export class NetCrs {
 
     const g1End = this.numPoints * 64 - 1;
 
-    const response = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g1.dat', {
-      headers: {
-        Range: `bytes=0-${g1End}`,
-      },
-      cache: 'force-cache',
-    });
+    const response = await retry(
+      () =>
+        fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g1.dat', {
+          headers: {
+            Range: `bytes=0-${g1End}`,
+          },
+          cache: 'force-cache',
+        }),
+      makeBackoff([5, 5, 5]),
+    );
 
     return (this.data = new Uint8Array(await response.arrayBuffer()));
   }
@@ -42,9 +47,13 @@ export class NetCrs {
    * Download the G2 points data.
    */
   async downloadG2Data() {
-    const response2 = await fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g2.dat', {
-      cache: 'force-cache',
-    });
+    const response2 = await retry(
+      () =>
+        fetch('https://aztec-ignition.s3.amazonaws.com/MAIN%20IGNITION/flat/g2.dat', {
+          cache: 'force-cache',
+        }),
+      makeBackoff([5, 5, 5]),
+    );
 
     return (this.g2Data = new Uint8Array(await response2.arrayBuffer()));
   }

package/src/crs/node/index.ts

@@ -45,7 +45,9 @@ export class Crs {
    * @returns The points data.
    */
   getG1Data(): Uint8Array {
-    const length = this.numPoints * 64;
+    // Ensure length > 0, otherwise we might read a huge file.
+    // This is a backup.
+    const length = Math.max(this.numPoints, 1) * 64;
     const fd = openSync(this.path + '/bn254_g1.dat', 'r');
     const buffer = new Uint8Array(length);
     readSync(fd, buffer, 0, length, 0);

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,10 +62,10 @@ 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) {
@@ -300,7 +300,7 @@ export async function gateCountUltra(bytecodePath: string, recursive: boolean, h
     const buffer = Buffer.alloc(8);
     buffer.writeBigInt64LE(BigInt(numberOfGates));
 
-    process.stdout.write(buffer);
+    process.stdout.write(Uint8Array.from(buffer));
   } finally {
     await api.destroy();
   }
@@ -310,7 +310,7 @@ 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));
+    const verified = await api.acirVerifyProof(acirComposer, Uint8Array.from(readFileSync(proofPath)));
     debug(`verified: ${verified}`);
     return verified;
   } finally {
@@ -406,7 +406,7 @@ export async function proofAsFields(proofPath: string, vkPath: string, outputPat
     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()));
@@ -521,7 +521,10 @@ 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}`);
     return verified;
@@ -534,7 +537,7 @@ export async function proofAsFieldsUltraHonk(proofPath: string, outputPath: stri
   const { api } = await initLite(crsPath);
   try {
     debug('outputting proof as vector of fields');
-    const proofAsFields = await api.acirProofAsFieldsUltraHonk(readFileSync(proofPath));
+    const proofAsFields = await api.acirProofAsFieldsUltraHonk(Uint8Array.from(readFileSync(proofPath)));
     const jsonProofAsFields = JSON.stringify(proofAsFields.map(f => f.toString()));
 
     if (outputPath === '-') {

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