@aztec/bb.js 0.67.1-devnet → 0.67.2-devnet

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aztec/bb.js",
-  "packageManager": "yarn@1.22.22",
-  "version": "0.67.1-devnet",
+  "packageManager": "yarn@4.5.2",
+  "version": "0.67.2-devnet",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/ts",
   "license": "MIT",
   "type": "module",
@@ -31,23 +31,34 @@
     "formatting": "prettier --check ./src && eslint --max-warnings 0 ./src",
     "formatting:fix": "prettier -w ./src",
     "test": "NODE_OPTIONS='--loader ts-node/esm' NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --passWithNoTests",
-    "test:debug": "NODE_OPTIONS='--loader ts-node/esm' NODE_NO_WARNINGS=1 node --inspect-brk=0.0.0.0 --experimental-vm-modules $(yarn bin jest) --no-cache --passWithNoTests --runInBand",
-    "simple_test": "NODE_OPTIONS='--loader ts-node/esm' NODE_NO_WARNINGS=1 node ./src/examples/simple.rawtest.ts",
+    "test:debug": "NODE_NO_WARNINGS=1 node --inspect-brk=0.0.0.0 --experimental-vm-modules ./node_modules/.bin/jest --no-cache --passWithNoTests --runInBand",
+    "simple_test": "NODE_NO_WARNINGS=1 node ./src/examples/simple.rawtest.ts",
     "deploy": "npm publish --access public"
   },
   "jest": {
     "preset": "ts-jest/presets/default-esm",
     "transform": {
-      "./src/.*\\.ts": [
-        "ts-jest",
+      "^.+\\.tsx?$": [
+        "@swc/jest",
         {
-          "useESM": true
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
         }
       ]
     },
     "moduleNameMapper": {
       "^(\\.{1,2}/.*)\\.js$": "$1"
     },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
     "testRegex": "./src/.*\\.test\\.ts$",
     "rootDir": "./src"
   },
@@ -62,6 +73,8 @@
   "devDependencies": {
     "@jest/globals": "^29.4.3",
     "@msgpack/msgpack": "^3.0.0-beta2",
+    "@swc/core": "^1.10.1",
+    "@swc/jest": "^0.2.37",
     "@types/debug": "^4.1.7",
     "@types/detect-node": "^2.0.0",
     "@types/jest": "^29.4.0",
@@ -79,6 +92,7 @@
     "jest": "^29.5.0",
     "prettier": "^2.8.4",
     "resolve-typescript-plugin": "^2.0.1",
+    "source-map-support": "^0.5.21",
     "ts-jest": "^29.1.0",
     "ts-loader": "^9.4.2",
     "ts-node": "^10.9.1",

package/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -1,6 +1,5 @@
 import createDebug from 'debug';
 import { randomBytes } from '../../random/index.js';
-import { killSelf } from '../helpers/index.js';
 
 const debug = createDebug('bb.js:wasm');
 
@@ -34,9 +33,8 @@ export class BarretenbergWasmBase {
           view.setBigUint64(out, ts, true);
         },
         proc_exit: () => {
-          this.logger('PANIC: proc_exit was called. This is maybe caused by "joining" with unstable wasi pthreads.');
-          this.logger(new Error().stack!);
-          killSelf();
+          this.logger('PANIC: proc_exit was called.');
+          throw new Error();
         },
       },
 

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