upgraded snarkjs version, added termination fix

package.json

@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "ejs": "3.1.10",
-    "snarkjs": "0.7.3"
+    "snarkjs": "0.7.5"
   },
   "devDependencies": {
     "@nomicfoundation/hardhat-ethers": "3.0.5",

src/constants.ts

@@ -0,0 +1 @@
+export const BN128_CURVE_NAME = "bn128";

src/core/CircuitZKit.ts

@@ -7,6 +7,8 @@ import { ArtifactsFileType, CircuitZKitConfig, VerifierLanguageType } from "../t
 import { Signals } from "../types/proof-utils";
 import { CalldataByProtocol, IProtocolImplementer, ProofStructByProtocol, ProvingSystemType } from "../types/protocols";
 
+import { getBn128Curve } from "../utils";
+
 /**
  * `CircuitZKit` represents a single circuit and provides a high-level API to work with it.
  */
@@ -45,9 +47,15 @@ export class CircuitZKit<Type extends ProvingSystemType> {
     const wtnsFile = path.join(tmpDir, `${this.getCircuitName()}.wtns`);
     const wasmFile = this.mustGetArtifactsFilePath("wasm");
 
+    const curve = await getBn128Curve();
+
     await snarkjs.wtns.calculate(inputs, wasmFile, wtnsFile);
 
-    return (await snarkjs.wtns.exportJson(wtnsFile)) as bigint[];
+    const wtnsJson = await snarkjs.wtns.exportJson(wtnsFile);
+
+    curve.terminate();
+
+    return wtnsJson as bigint[];
   }
 
   /**

src/core/protocols/Groth16Implementer.ts

@@ -6,20 +6,38 @@ import { AbstractProtocolImplementer } from "./AbstractImplementer";
 import { Signals } from "../../types/proof-utils";
 import { Groth16ProofStruct, ProvingSystemType, Groth16Calldata } from "../../types/protocols";
 
+import { getBn128Curve } from "../../utils";
+
 export class Groth16Implementer extends AbstractProtocolImplementer<"groth16"> {
   public async generateProof(inputs: Signals, zKeyFilePath: string, wasmFilePath: string): Promise<Groth16ProofStruct> {
-    return (await snarkjs.groth16.fullProve(inputs, wasmFilePath, zKeyFilePath)) as Groth16ProofStruct;
+    const curve = await getBn128Curve();
+
+    const fullProof = await snarkjs.groth16.fullProve(inputs, wasmFilePath, zKeyFilePath);
+
+    curve.terminate();
+
+    return fullProof as Groth16ProofStruct;
   }
 
   public async verifyProof(proof: Groth16ProofStruct, vKeyFilePath: string): Promise<boolean> {
     const verifier = JSON.parse(fs.readFileSync(vKeyFilePath).toString());
 
-    return await snarkjs.groth16.verify(verifier, proof.publicSignals, proof.proof);
+    const curve = await getBn128Curve();
+
+    const proofVerification = await snarkjs.groth16.verify(verifier, proof.publicSignals, proof.proof);
+
+    curve.terminate();
+
+    return proofVerification;
   }
 
   public async generateCalldata(proof: Groth16ProofStruct): Promise<Groth16Calldata> {
+    const curve = await getBn128Curve();
+
     const calldata = await snarkjs.groth16.exportSolidityCallData(proof.proof, proof.publicSignals);
 
+    curve.terminate();
+
     return JSON.parse(`[${calldata}]`) as Groth16Calldata;
   }
 

src/core/protocols/PlonkImplementer.ts

@@ -6,21 +6,39 @@ import { AbstractProtocolImplementer } from "./AbstractImplementer";
 import { Signals } from "../../types/proof-utils";
 import { PlonkCalldata, PlonkProofStruct, ProvingSystemType } from "../../types/protocols";
 
+import { getBn128Curve } from "../../utils";
+
 export class PlonkImplementer extends AbstractProtocolImplementer<"plonk"> {
   public async generateProof(inputs: Signals, zKeyFilePath: string, wasmFilePath: string): Promise<PlonkProofStruct> {
-    return (await snarkjs.plonk.fullProve(inputs, wasmFilePath, zKeyFilePath)) as PlonkProofStruct;
+    const curve = await getBn128Curve();
+
+    const fullProof = await snarkjs.plonk.fullProve(inputs, wasmFilePath, zKeyFilePath);
+
+    curve.terminate();
+
+    return fullProof as PlonkProofStruct;
   }
 
   public async verifyProof(proof: PlonkProofStruct, vKeyFilePath: string): Promise<boolean> {
+    const curve = await getBn128Curve();
+
     const verifier = JSON.parse(fs.readFileSync(vKeyFilePath).toString());
 
-    return await snarkjs.plonk.verify(verifier, proof.publicSignals, proof.proof);
+    const proofVerification = await snarkjs.plonk.verify(verifier, proof.publicSignals, proof.proof);
+
+    curve.terminate();
+
+    return proofVerification;
   }
 
   public async generateCalldata(proof: PlonkProofStruct): Promise<PlonkCalldata> {
+    const curve = await getBn128Curve();
+
     const calldata = await snarkjs.plonk.exportSolidityCallData(proof.proof, proof.publicSignals);
     const proofArrEndIndex: number = calldata.indexOf("]") + 1;
 
+    curve.terminate();
+
     return JSON.parse(
       `[${calldata.slice(0, proofArrEndIndex)},${calldata.slice(proofArrEndIndex, calldata.length)}]`,
     ) as PlonkCalldata;

src/utils.ts

@@ -0,0 +1,6 @@
+import * as snarkjs from "snarkjs";
+import { BN128_CURVE_NAME } from "./constants";
+
+export async function getBn128Curve() {
+  return (snarkjs as any).curves.getCurveFromName(BN128_CURVE_NAME);
+}