@aztec/bb.js 0.67.1 → 0.68.0

package/src/barretenberg_wasm/helpers/browser/index.ts

@@ -1,7 +1,7 @@
 import { wrap } from 'comlink';
 
 export function getSharedMemoryAvailable() {
-  const globalScope = typeof window !== 'undefined' ? window : self;
+  const globalScope = typeof window !== 'undefined' ? window : globalThis;
   return typeof SharedArrayBuffer !== 'undefined' && globalScope.crossOriginIsolated;
 }
 

package/src/crs/node/index.ts

@@ -1,5 +1,5 @@
 import { NetCrs, NetGrumpkinCrs } from '../net_crs.js';
-import { mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from 'fs';
 import { stat } from 'fs/promises';
 import createDebug from 'debug';
 import { homedir } from 'os';
@@ -45,7 +45,12 @@ export class Crs {
    * @returns The points data.
    */
   getG1Data(): Uint8Array {
-    return readFileSync(this.path + '/bn254_g1.dat');
+    const length = this.numPoints * 64;
+    const fd = openSync(this.path + '/bn254_g1.dat', 'r');
+    const buffer = new Uint8Array(length);
+    readSync(fd, buffer, 0, length, 0);
+    closeSync(fd);
+    return buffer;
   }
 
   /**

package/src/main.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import 'source-map-support/register.js';
 import { Crs, GrumpkinCrs, Barretenberg, RawBuffer } from './index.js';
 import createDebug from 'debug';
 import { readFileSync, writeFileSync } from 'fs';
@@ -141,11 +142,11 @@ async function initClientIVC(crsPath: string) {
   return { api };
 }
 
-async function initLite() {
+async function initLite(crsPath: string) {
   const api = await Barretenberg.new({ threads: 1 });
 
   // Plus 1 needed! (Move +1 into Crs?)
-  const crs = await Crs.new(1);
+  const crs = await Crs.new(1, crsPath);
 
   // Load CRS into wasm global CRS state.
   await api.srsInitSrs(new RawBuffer(crs.getG1Data()), crs.numPoints, new RawBuffer(crs.getG2Data()));
@@ -305,8 +306,8 @@ export async function gateCountUltra(bytecodePath: string, recursive: boolean, h
   }
 }
 
-export async function verify(proofPath: string, vkPath: string) {
-  const { api, acirComposer } = await initLite();
+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));
@@ -317,8 +318,8 @@ export async function verify(proofPath: string, vkPath: string) {
   }
 }
 
-export async function contract(outputPath: string, vkPath: string) {
-  const { api, acirComposer } = await initLite();
+export async function contract(outputPath: string, vkPath: string, crsPath: string) {
+  const { api, acirComposer } = await initLite(crsPath);
   try {
     await api.acirLoadVerificationKey(acirComposer, new RawBuffer(readFileSync(vkPath)));
     const contract = await api.acirGetSolidityVerifier(acirComposer);
@@ -397,8 +398,8 @@ export async function writePk(bytecodePath: string, recursive: boolean, crsPath:
   }
 }
 
-export async function proofAsFields(proofPath: string, vkPath: string, outputPath: string) {
-  const { api, acirComposer } = await initLite();
+export async function proofAsFields(proofPath: string, vkPath: string, outputPath: string, crsPath: string) {
+  const { api, acirComposer } = await initLite(crsPath);
 
   try {
     debug('serializing proof byte array into field elements');
@@ -424,8 +425,8 @@ export async function proofAsFields(proofPath: string, vkPath: string, outputPat
   }
 }
 
-export async function vkAsFields(vkPath: string, vkeyOutputPath: string) {
-  const { api, acirComposer } = await initLite();
+export async function vkAsFields(vkPath: string, vkeyOutputPath: string, crsPath: string) {
+  const { api, acirComposer } = await initLite(crsPath);
 
   try {
     debug('serializing vk byte array into field elements');
@@ -509,8 +510,13 @@ export async function writeVkUltraHonk(
   }
 }
 
-export async function verifyUltraHonk(proofPath: string, vkPath: string, options?: UltraHonkBackendOptions) {
-  const { api } = await initLite();
+export async function verifyUltraHonk(
+  proofPath: string,
+  vkPath: string,
+  crsPath: string,
+  options?: UltraHonkBackendOptions,
+) {
+  const { api } = await initLite(crsPath);
   try {
     const acirVerifyUltraHonk = options?.keccak
       ? api.acirVerifyUltraKeccakHonk.bind(api)
@@ -524,8 +530,8 @@ export async function verifyUltraHonk(proofPath: string, vkPath: string, options
   }
 }
 
-export async function proofAsFieldsUltraHonk(proofPath: string, outputPath: string) {
-  const { api } = await initLite();
+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));
@@ -545,8 +551,8 @@ export async function proofAsFieldsUltraHonk(proofPath: string, outputPath: stri
   }
 }
 
-export async function vkAsFieldsUltraHonk(vkPath: string, vkeyOutputPath: string) {
-  const { api } = await initLite();
+export async function vkAsFieldsUltraHonk(vkPath: string, vkeyOutputPath: string, crsPath: string) {
+  const { api } = await initLite(crsPath);
 
   try {
     debug('serializing vk byte array into field elements');
@@ -576,6 +582,7 @@ function handleGlobalOptions() {
   if (program.opts().verbose) {
     createDebug.enable('bb.js*');
   }
+  return { crsPath: program.opts().crsPath };
 }
 
 program
@@ -584,8 +591,8 @@ program
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
-  .action(async ({ bytecodePath, recursive, witnessPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
     const result = await proveAndVerify(bytecodePath, recursive, witnessPath, crsPath);
     process.exit(result ? 0 : 1);
   });
@@ -596,8 +603,8 @@ program
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
-  .action(async ({ bytecodePath, recursive, witnessPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
     const result = await proveAndVerifyUltraHonk(bytecodePath, recursive, witnessPath, crsPath);
     process.exit(result ? 0 : 1);
   });
@@ -608,8 +615,8 @@ program
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-r, --recursive', 'Whether to use a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
-  .action(async ({ bytecodePath, recursive, witnessPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
     const result = await proveAndVerifyMegaHonk(bytecodePath, recursive, witnessPath, crsPath);
     process.exit(result ? 0 : 1);
   });
@@ -619,8 +626,8 @@ program
   .description('Generate a ClientIVC proof.')
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/acir.msgpack.b64')
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witnesses.msgpack.b64')
-  .action(async ({ bytecodePath, witnessPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
     const result = await proveAndVerifyAztecClient(bytecodePath, witnessPath, crsPath);
     process.exit(result ? 0 : 1);
   });
@@ -631,8 +638,8 @@ program
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
-  .action(async ({ bytecodePath, recursive, witnessPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, witnessPath }) => {
+    const { crsPath } = handleGlobalOptions();
     const result = await foldAndVerifyProgram(bytecodePath, recursive, witnessPath, crsPath);
     process.exit(result ? 0 : 1);
   });
@@ -644,8 +651,8 @@ program
   .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
   .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ bytecodePath, recursive, witnessPath, outputPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, witnessPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
     await prove(bytecodePath, recursive, witnessPath, crsPath, outputPath);
   });
 
@@ -666,8 +673,8 @@ program
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
   .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
   .action(async ({ proofPath, vk }) => {
-    handleGlobalOptions();
-    const result = await verify(proofPath, vk);
+    const { crsPath } = handleGlobalOptions();
+    const result = await verify(proofPath, vk, crsPath);
     process.exit(result ? 0 : 1);
   });
 
@@ -678,8 +685,8 @@ program
   .option('-o, --output-path <path>', 'Specify the path to write the contract', './target/contract.sol')
   .requiredOption('-k, --vk-path <path>', 'Path to a verification key. avoids recomputation.')
   .action(async ({ outputPath, vkPath }) => {
-    handleGlobalOptions();
-    await contract(outputPath, vkPath);
+    const { crsPath } = handleGlobalOptions();
+    await contract(outputPath, vkPath, crsPath);
   });
 
 program
@@ -699,8 +706,8 @@ program
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .option('-o, --output-path <path>', 'Specify the path to write the key')
-  .action(async ({ bytecodePath, recursive, outputPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
     await writeVk(bytecodePath, recursive, crsPath, outputPath);
   });
 
@@ -710,8 +717,8 @@ program
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
-  .action(async ({ bytecodePath, recursive, outputPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
     await writePk(bytecodePath, recursive, crsPath, outputPath);
   });
 
@@ -722,8 +729,8 @@ program
   .requiredOption('-k, --vk-path <path>', 'Path to verification key.')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
   .action(async ({ proofPath, vkPath, outputPath }) => {
-    handleGlobalOptions();
-    await proofAsFields(proofPath, vkPath, outputPath);
+    const { crsPath } = handleGlobalOptions();
+    await proofAsFields(proofPath, vkPath, outputPath, crsPath);
   });
 
 program
@@ -732,8 +739,8 @@ program
   .requiredOption('-k, --vk-path <path>', 'Path to verification key.')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the verification key fields and key hash')
   .action(async ({ vkPath, outputPath }) => {
-    handleGlobalOptions();
-    await vkAsFields(vkPath, outputPath);
+    const { crsPath } = handleGlobalOptions();
+    await vkAsFields(vkPath, outputPath, crsPath);
   });
 
 program
@@ -743,8 +750,8 @@ program
   .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .option('-w, --witness-path <path>', 'Specify the witness path', './target/witness.gz')
   .option('-o, --output-path <path>', 'Specify the proof output path', './proofs/proof')
-  .action(async ({ bytecodePath, recursive, witnessPath, outputPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, witnessPath, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
     await proveUltraHonk(bytecodePath, recursive, witnessPath, crsPath, outputPath);
   });
 
@@ -766,8 +773,8 @@ program
   .option('-b, --bytecode-path <path>', 'Specify the bytecode path', './target/program.json')
   .option('-r, --recursive', 'Create a SNARK friendly proof', false)
   .requiredOption('-o, --output-path <path>', 'Specify the path to write the key')
-  .action(async ({ bytecodePath, recursive, outputPath, crsPath }) => {
-    handleGlobalOptions();
+  .action(async ({ bytecodePath, recursive, outputPath }) => {
+    const { crsPath } = handleGlobalOptions();
     await writeVkUltraHonk(bytecodePath, recursive, crsPath, outputPath);
   });
 
@@ -788,8 +795,8 @@ program
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
   .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
   .action(async ({ proofPath, vk }) => {
-    handleGlobalOptions();
-    const result = await verifyUltraHonk(proofPath, vk);
+    const { crsPath } = handleGlobalOptions();
+    const result = await verifyUltraHonk(proofPath, vk, crsPath);
     process.exit(result ? 0 : 1);
   });
 
@@ -799,8 +806,8 @@ program
   .requiredOption('-p, --proof-path <path>', 'Specify the path to the proof')
   .requiredOption('-k, --vk <path>', 'path to a verification key. avoids recomputation.')
   .action(async ({ proofPath, vk }) => {
-    handleGlobalOptions();
-    const result = await verifyUltraHonk(proofPath, vk, { keccak: true });
+    const { crsPath } = handleGlobalOptions();
+    const result = await verifyUltraHonk(proofPath, vk, crsPath, { keccak: true });
     process.exit(result ? 0 : 1);
   });
 
@@ -810,8 +817,8 @@ program
   .requiredOption('-p, --proof-path <path>', 'Specify the proof path')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the proof fields')
   .action(async ({ proofPath, outputPath }) => {
-    handleGlobalOptions();
-    await proofAsFieldsUltraHonk(proofPath, outputPath);
+    const { crsPath } = handleGlobalOptions();
+    await proofAsFieldsUltraHonk(proofPath, outputPath, crsPath);
   });
 
 program
@@ -820,8 +827,8 @@ program
   .requiredOption('-k, --vk-path <path>', 'Path to verification key.')
   .requiredOption('-o, --output-path <path>', 'Specify the JSON path to write the verification key fields.')
   .action(async ({ vkPath, outputPath }) => {
-    handleGlobalOptions();
-    await vkAsFieldsUltraHonk(vkPath, outputPath);
+    const { crsPath } = handleGlobalOptions();
+    await vkAsFieldsUltraHonk(vkPath, outputPath, crsPath);
   });
 
 program.name('bb.js').parse(process.argv);

package/src/random/browser/index.ts

@@ -1,7 +1,7 @@
 export const randomBytes = (len: number) => {
   const getWebCrypto = () => {
     if (typeof window !== 'undefined' && window.crypto) return window.crypto;
-    if (typeof self !== 'undefined' && self.crypto) return self.crypto;
+    if (typeof globalThis !== 'undefined' && globalThis.crypto) return globalThis.crypto;
     return undefined;
   };