@solarity/zkit 0.1.1 → 0.2.0

package/README.md

@@ -3,12 +3,11 @@
 
 # ZKit - Circom Zero Knowledge Kit
 
-**A zero knowledge kit that helps you develop circuits using Circom.**
+**A zero knowledge kit that helps you interact with Circom circuits.**
 
-- Compile and interact with circuits without snarkjs hassle.
 - Generate and verify ZK proofs with a single line of code.
 - Render optimized Solidity verifiers.
-- Forget about native dependencies - everything is in TypeScript.
+- Build and work with ZK witnesses.
 
 ## Installation
 
@@ -20,67 +19,42 @@ npm install --save-dev @solarity/zkit
 
 ## Usage
 
-### CircomZKit
-
-ZKit is a configless package, which means you don't need to provide any configuration to use it:
-
-```typescript
-import { CircomZKit } from "@solarity/zkit";
-
-async function main() {
-  const zkit = new CircomZKit();
-  
-  const multiplier = zkit.getCircuit("Multiplier");
-  
-  // Generates artifacts in the "./zkit-artifacts" directory
-  await multiplier.compile();
-
-  // Generates ZK proof
-  const proof = await multiplier.generateProof({ a: 2, b: 3});
-}
-```
-
-By default, ZKit will look for the circuit file in the `./circuits` directory. However, you can change this by providing a custom one:
-
-```typescript
-new CircomZKit({ circuitsDir: "./my-circuits" });
-```
-
-To generate zkey, the power-of-tau file is required. ZKit automatically downloads those files from [Hermes](https://hermez.s3-eu-west-1.amazonaws.com/) to the `${HOME}/.zkit/.ptau` directory, so you don't need to re-download them every time you start a new project.
-
-You can also provide a custom path to the directory where the power-of-tau files are stored:
+> [!IMPORTANT]
+> The kit is not meant to be used directly as its fitness relies heavily on the environment, Circom compilation artifacts management, processing of remappings, etc. Consider using [hardhat-zkit](https://github.com/dl-solarity/hardhat-zkit) which is a complete, developer-friendly package.
 
-```typescript
-new CircomZKit({ ptauDir: "./my-ptau" });
-```
+### CircuitZKit
 
-> [!IMPORTANT]
-> Note that all the files in the `ptauDir` directory must have the `powers-of-tau-{x}.ptau` name format, where `{x}` is a maximum degree (2<sup>x</sup>) of constraints a `ptau` supports.
+`CircuitZKit` is a user-friendly interface for interacting with circom circuits.
 
-ZKit may also ask you for the permission to download the power-of-tau files. You can enable this by toggling off the `allowDownload` option:
+To create a CircuitZKit object it is necessary to pass a config:
 
 ```typescript
-new CircomZKit({ allowDownload: false });
+CircuitZKitConfig = {
+  circuitName: string;
+  circuitArtifactsPath: string;
+  verifierDirPath: string;
+  templateType?: VerifierTemplateType;
+};
 ```
 
-### CircuitZKit
-
-Once you created a `CircuitZKit` instance using the `getCircuit` method, you can manage the underlying circuit using the following methods:
+This config contains all the information required to work with the circuit, namely:
 
-> [!NOTE]
-> You should first compile the circuit before creating verifiers or generating proofs.
+- `circuitName` - Name of the circuit file without extension
+- `circuitArtifactsPath` - Full path to compilation artifacts for the desired circuit
+- `verifierDirPath` - Full path to the directory where Solidity verifier file will be generated
+- `templateType` - The type of template that will be used to generate the Solidity verifier contract. Right now only `groth16` is supported
 
-#### compile()
+#### getTemplate()
 
-Compiles the circuit and generates the artifacts in the `./zkit-artifacts` or in the provided `artifactsDir` directory. The default output is `r1cs`, `zkey` and `vkey` files.
+Static `CircuitZKit` function that returns the contents of a template file by the passed type.
 
 ```typescript
-await multiplier.compile();
+const templateContent = CircuitZKit.getTemplate("groth16");
 ```
 
 #### createVerifier()
 
-Creates Solidity verifier contract  in the `./contracts/verifiers` or in the provided `verifiersDir` directory. 
+Creates a Solidity verifier contract on `verifierDirPath` path, which was specified in the config.
 
 ```typescript
 await multiplier.createVerifier();
@@ -92,7 +66,7 @@ Generates a proof for the given inputs.
 
 ```typescript
 /// { proof: { pi_a, pi_b, pi_c, protocol, curve }, publicSignals: [6] }
-const proof = await multiplier.generateProof({ a: 2, b: 3});
+const proof = await multiplier.generateProof({ a: 2, b: 3 });
 ```
 
 #### verifyProof()
@@ -116,5 +90,3 @@ const calldata = await multiplier.generateCalldata(proof);
 ## Known limitations
 
 - Currently, ZKit supports only the Groth16 proving system.
-- Zkey generation doesn't allow additional contributions.
-- The `compile` method may cause [issues](https://github.com/iden3/snarkjs/issues/494).

package/dist/core/CircuitZKit.d.ts

@@ -1,32 +1,19 @@
-import { CompileOptions } from "../config/config";
-import { ManagerZKit } from "./ManagerZKit";
-import { Calldata, Inputs, ProofStruct } from "../types/types";
+import { ArtifactsFileType, Calldata, CircuitZKitConfig, Inputs, ProofStruct, VerifierTemplateType } from "../types/circuit-zkit";
 /**
  * `CircuitZKit` represents a single circuit and provides a high-level API to work with it.
- *
- * @dev This class is not meant to be used directly. Use the `CircomZKit` to create its instance.
  */
 export declare class CircuitZKit {
-    private readonly _circuit;
-    private readonly _manager;
+    private readonly _config;
+    constructor(_config: CircuitZKitConfig);
     /**
-     * Creates a new instance of `CircuitZKit`.
+     * Returns the Solidity verifier template for the specified proving system.
      *
-     * @param {string} _circuit - The path to the circuit.
-     * @param {ManagerZKit} _manager - The manager that maintains the global state.
+     * @param {VerifierTemplateType} templateType - The template type.
+     * @returns {string} The Solidity verifier template.
      */
-    constructor(_circuit: string, _manager: ManagerZKit);
+    static getTemplate(templateType: VerifierTemplateType): string;
     /**
-     * Compiles the circuit and generates the artifacts.
-     *
-     * @dev If compilation fails, the latest valid artifacts will be preserved.
-     * @dev Doesn't show the compilation error if `quiet` is set to `true`.
-     *
-     * @param {Partial<CompileOptions>} [options=defaultCompileOptions] - Compilation options.
-     */
-    compile(options?: Partial<CompileOptions>): Promise<void>;
-    /**
-     * Creates a verifier contract.
+     * Creates a Solidity verifier contract.
      */
     createVerifier(): Promise<void>;
     /**
@@ -58,90 +45,36 @@ export declare class CircuitZKit {
      */
     generateCalldata(proof: ProofStruct): Promise<Calldata>;
     /**
-     * Returns the circuit ID. The circuit ID is the name of the circuit file without the extension.
-     *
-     * @returns {string} The circuit ID.
-     */
-    getCircuitId(): string;
-    /**
-     * Returns the verifier ID. The verifier ID is the name of the circuit file without the extension, suffixed with "Verifier".
-     *
-     * @returns {string} The verifier ID.
-     */
-    getVerifierId(): string;
-    /**
-     * Generates zero-knowledge key for the circuit.
-     *
-     * @param {CompileOptions} options - Compilation options.
-     * @param {string} outDir - The directory to save the generated key.
-     * @todo This method may cause issues https://github.com/iden3/snarkjs/issues/494
-     */
-    private _generateZKey;
-    /**
-     * Generates verification key for the circuit.
+     * Returns the circuit name. The circuit name is the name of the circuit file without the extension.
      *
-     * @param {string} outDir - The directory to save the generated key.
+     * @returns {string} The circuit name.
      */
-    private _generateVKey;
+    getCircuitName(): string;
     /**
-     * Returns the arguments to compile the circuit.
+     * Returns the verifier name. The verifier name is the name of the circuit file without the extension, suffixed with "Verifier".
      *
-     * @param {CompileOptions} options - Compilation options.
-     * @param {string} outDir - The directory to save the compiled artifacts.
-     * @returns {string[]} The arguments to compile the circuit.
+     * @returns {string} The verifier name.
      */
-    private _getCompileArgs;
+    getVerifierName(): string;
     /**
-     * Compiles the circuit.
+     * Returns the type of verifier template that was stored in the config
      *
-     * @param {CompileOptions} options - Compilation options.
-     * @param {string} outDir - The directory to save the compiled artifacts.
+     * @returns {VerifierTemplateType} The verifier template type.
      */
-    private _compile;
+    getTemplateType(): VerifierTemplateType;
     /**
-     * Returns the number of constraints in the circuit. This value is used to fetch the correct `ptau` file.
+     * Returns the path to the file of the given type inside artifacts directory. Throws an error if the file doesn't exist.
      *
-     * @param {string} outDir - The directory where the compiled artifacts are saved.
-     * @returns {Promise<number>} The number of constraints in the circuit.
-     */
-    _getConstraints(outDir: string): Promise<number>;
-    /**
-     * Returns the path to the file of the given type.
-     *
-     * @param {FileType} fileType - The type of the file.
-     * @param {string | undefined} temp - The temporary directory to use.
+     * @param {ArtifactsFileType} fileType - The type of the file.
      * @returns {string} The path to the file.
      */
-    private _getFile;
-    /**
-     * Returns the path to the directory of the given type.
-     *
-     * @param {DirType} dirType - The type of the directory.
-     * @returns {string} The path to the directory.
-     */
-    private _getDir;
+    mustGetArtifactsFilePath(fileType: ArtifactsFileType): string;
     /**
-     * Returns the path to the file of the given type. Throws an error if the file doesn't exist.
+     * Returns the path to the file of the given type inside artifacts directory.
      *
-     * @param {FileType} fileType - The type of the file.
-     * @param {string | undefined} temp - The temporary directory to use.
+     * @param {ArtifactsFileType} fileType - The type of the file.
      * @returns {string} The path to the file.
      */
-    private _mustGetFile;
-    /**
-     * Moves the files from the temporary directory to the output directory.
-     *
-     * @param {string} tempDir - The temporary directory.
-     * @param {string} outDir - The output directory.
-     */
-    private _moveFromTempDirToOutDir;
-    /**
-     * Returns a new instance of `CircomRunner`. The `CircomRunner` is used to compile the circuit.
-     *
-     * @param {string[]} args - The arguments to run the `circom` compiler.
-     * @param {boolean} quiet - Whether to suppress the compilation error.
-     * @returns {typeof CircomRunner} The `CircomRunner` instance.
-     */
-    private _getCircomRunner;
+    getArtifactsFilePath(fileType: ArtifactsFileType): string;
 }
 //# sourceMappingURL=CircuitZKit.d.ts.map

package/dist/core/CircuitZKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CircuitZKit.d.ts","sourceRoot":"","sources":["../../src/core/CircuitZKit.ts"],"names":[],"mappings":"AAMA,OAAO,EAAyB,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAqB,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKlF;;;;GAIG;AACH,qBAAa,WAAW;IAQpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAR3B;;;;;OAKG;gBAEgB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW;IAGxC;;;;;;;OAOG;IACU,OAAO,CAAC,OAAO,GAAE,OAAO,CAAC,cAAc,CAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7F;;OAEG;IACU,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B5C;;;;;;;;OAQG;IACU,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAOhE;;;;;;;;OAQG;IACU,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ9D;;;;;;OAMG;IACU,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMpE;;;;OAIG;IACI,YAAY,IAAI,MAAM;IAI7B;;;;OAIG;IACI,aAAa,IAAI,MAAM;IAI9B;;;;;;OAMG;YACW,aAAa;IA0B3B;;;;OAIG;YACW,aAAa;IAS3B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAYvB;;;;;OAKG;YACW,QAAQ;IAiBtB;;;;;OAKG;IACG,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkCtD;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAuBhB;;;;;OAKG;IACH,OAAO,CAAC,OAAO;IAef;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAUpB;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAmBhC;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;CAczB"}
+{"version":3,"file":"CircuitZKit.d.ts","sourceRoot":"","sources":["../../src/core/CircuitZKit.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,iBAAiB,EACjB,QAAQ,EACR,iBAAiB,EACjB,MAAM,EACN,WAAW,EACX,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,iBAAiB;IAEvD;;;;;OAKG;WACW,WAAW,CAAC,YAAY,EAAE,oBAAoB,GAAG,MAAM;IASrE;;OAEG;IACU,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5C;;;;;;;;OAQG;IACU,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAOhE;;;;;;;;OAQG;IACU,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ9D;;;;;;OAMG;IACU,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMpE;;;;OAIG;IACI,cAAc,IAAI,MAAM;IAI/B;;;;OAIG;IACI,eAAe,IAAI,MAAM;IAIhC;;;;OAIG;IACI,eAAe,IAAI,oBAAoB;IAI9C;;;;;OAKG;IACI,wBAAwB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM;IAUpE;;;;;OAKG;IACI,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM;CAgCjE"}

package/dist/core/CircuitZKit.js

@@ -27,75 +27,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CircuitZKit = void 0;
-const crypto_1 = require("crypto");
 const ejs_1 = __importDefault(require("ejs"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const snarkjs = __importStar(require("snarkjs"));
-const config_1 = require("../config/config");
-const utils_1 = require("../utils/utils");
-const { CircomRunner, bindings } = require("@distributedlab/circom2");
 /**
  * `CircuitZKit` represents a single circuit and provides a high-level API to work with it.
- *
- * @dev This class is not meant to be used directly. Use the `CircomZKit` to create its instance.
  */
 class CircuitZKit {
-    _circuit;
-    _manager;
-    /**
-     * Creates a new instance of `CircuitZKit`.
-     *
-     * @param {string} _circuit - The path to the circuit.
-     * @param {ManagerZKit} _manager - The manager that maintains the global state.
-     */
-    constructor(_circuit, _manager) {
-        this._circuit = _circuit;
-        this._manager = _manager;
+    _config;
+    constructor(_config) {
+        this._config = _config;
     }
     /**
-     * Compiles the circuit and generates the artifacts.
-     *
-     * @dev If compilation fails, the latest valid artifacts will be preserved.
-     * @dev Doesn't show the compilation error if `quiet` is set to `true`.
+     * Returns the Solidity verifier template for the specified proving system.
      *
-     * @param {Partial<CompileOptions>} [options=defaultCompileOptions] - Compilation options.
+     * @param {VerifierTemplateType} templateType - The template type.
+     * @returns {string} The Solidity verifier template.
      */
-    async compile(options = config_1.defaultCompileOptions) {
-        const tempDir = this._manager.getTempDir();
-        try {
-            const artifactDir = this._getDir("artifact");
-            fs_1.default.mkdirSync(tempDir, { recursive: true });
-            const overriddenOptions = { ...config_1.defaultCompileOptions, ...options };
-            await this._compile(overriddenOptions, tempDir);
-            await this._generateZKey(overriddenOptions, tempDir);
-            await this._generateVKey(tempDir);
-            this._moveFromTempDirToOutDir(tempDir, artifactDir);
-        }
-        finally {
-            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    static getTemplate(templateType) {
+        switch (templateType) {
+            case "groth16":
+                return fs_1.default.readFileSync(path_1.default.join(__dirname, "templates", "verifier_groth16.sol.ejs"), "utf8");
+            default:
+                throw new Error(`Ambiguous template type: ${templateType}.`);
         }
     }
     /**
-     * Creates a verifier contract.
+     * Creates a Solidity verifier contract.
      */
     async createVerifier() {
-        const tempDir = this._manager.getTempDir();
-        try {
-            const verifierDir = this._getDir("verifier");
-            fs_1.default.mkdirSync(tempDir, { recursive: true });
-            const vKeyFile = this._mustGetFile("vkey");
-            const verifierFile = this._getFile("sol", tempDir);
-            const groth16Template = this._manager.getTemplate("groth16");
-            const templateParams = JSON.parse(fs_1.default.readFileSync(vKeyFile, "utf-8"));
-            templateParams["verifier_id"] = this.getVerifierId();
-            const verifierCode = ejs_1.default.render(groth16Template, templateParams);
-            fs_1.default.writeFileSync(verifierFile, verifierCode, "utf-8");
-            this._moveFromTempDirToOutDir(tempDir, verifierDir);
-        }
-        finally {
-            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        const vKeyFilePath = this.mustGetArtifactsFilePath("vkey");
+        const verifierFilePath = path_1.default.join(this._config.verifierDirPath, `${this.getVerifierName()}.sol`);
+        const verifierTemplate = CircuitZKit.getTemplate(this.getTemplateType());
+        if (!fs_1.default.existsSync(this._config.verifierDirPath)) {
+            fs_1.default.mkdirSync(this._config.verifierDirPath, { recursive: true });
         }
+        const templateParams = JSON.parse(fs_1.default.readFileSync(vKeyFilePath, "utf-8"));
+        templateParams["verifier_id"] = this.getVerifierName();
+        const verifierCode = ejs_1.default.render(verifierTemplate, templateParams);
+        fs_1.default.writeFileSync(verifierFilePath, verifierCode, "utf-8");
     }
     /**
      * Generates a proof for the given inputs.
@@ -107,8 +78,8 @@ class CircuitZKit {
      * @todo Add support for other proving systems.
      */
     async generateProof(inputs) {
-        const zKeyFile = this._mustGetFile("zkey");
-        const wasmFile = this._mustGetFile("wasm");
+        const zKeyFile = this.mustGetArtifactsFilePath("zkey");
+        const wasmFile = this.mustGetArtifactsFilePath("wasm");
         return (await snarkjs.groth16.fullProve(inputs, wasmFile, zKeyFile));
     }
     /**
@@ -121,7 +92,7 @@ class CircuitZKit {
      * @returns {Promise<boolean>} Whether the proof is valid.
      */
     async verifyProof(proof) {
-        const vKeyFile = this._mustGetFile("vkey");
+        const vKeyFile = this.mustGetArtifactsFilePath("vkey");
         const verifier = JSON.parse(fs_1.default.readFileSync(vKeyFile).toString());
         return await snarkjs.groth16.verify(verifier, proof.publicSignals, proof.proof);
     }
@@ -137,217 +108,76 @@ class CircuitZKit {
         return JSON.parse(`[${calldata}]`);
     }
     /**
-     * Returns the circuit ID. The circuit ID is the name of the circuit file without the extension.
+     * Returns the circuit name. The circuit name is the name of the circuit file without the extension.
      *
-     * @returns {string} The circuit ID.
+     * @returns {string} The circuit name.
      */
-    getCircuitId() {
-        return path_1.default.parse(this._circuit).name;
+    getCircuitName() {
+        return this._config.circuitName;
     }
     /**
-     * Returns the verifier ID. The verifier ID is the name of the circuit file without the extension, suffixed with "Verifier".
+     * Returns the verifier name. The verifier name is the name of the circuit file without the extension, suffixed with "Verifier".
      *
-     * @returns {string} The verifier ID.
+     * @returns {string} The verifier name.
      */
-    getVerifierId() {
-        return `${path_1.default.parse(this._circuit).name}Verifier`;
+    getVerifierName() {
+        return `${this._config.circuitName}Verifier`;
     }
     /**
-     * Generates zero-knowledge key for the circuit.
+     * Returns the type of verifier template that was stored in the config
      *
-     * @param {CompileOptions} options - Compilation options.
-     * @param {string} outDir - The directory to save the generated key.
-     * @todo This method may cause issues https://github.com/iden3/snarkjs/issues/494
+     * @returns {VerifierTemplateType} The verifier template type.
      */
-    async _generateZKey(options, outDir) {
-        const r1csFile = this._getFile("r1cs", outDir);
-        const zKeyFile = this._getFile("zkey", outDir);
-        const constraints = await this._getConstraints(outDir);
-        const ptauFile = await this._manager.fetchPtauFile(constraints);
-        if (options.setup == "groth16") {
-            await snarkjs.zKey.newZKey(r1csFile, ptauFile, zKeyFile);
-            const zKeyFileNext = `${zKeyFile}.next.zkey`;
-            for (let i = 0; i < options.contributions; ++i) {
-                await snarkjs.zKey.contribute(zKeyFile, zKeyFileNext, `${zKeyFile}_contribution_${i}`, (0, crypto_1.randomBytes)(32).toString("hex"));
-                fs_1.default.rmSync(zKeyFile);
-                fs_1.default.renameSync(zKeyFileNext, zKeyFile);
-            }
-        }
-    }
-    /**
-     * Generates verification key for the circuit.
-     *
-     * @param {string} outDir - The directory to save the generated key.
-     */
-    async _generateVKey(outDir) {
-        const zKeyFile = this._getFile("zkey", outDir);
-        const vKeyFile = this._getFile("vkey", outDir);
-        const vKeyData = await snarkjs.zKey.exportVerificationKey(zKeyFile);
-        fs_1.default.writeFileSync(vKeyFile, JSON.stringify(vKeyData));
+    getTemplateType() {
+        return this._config.templateType ?? "groth16";
     }
     /**
-     * Returns the arguments to compile the circuit.
+     * Returns the path to the file of the given type inside artifacts directory. Throws an error if the file doesn't exist.
      *
-     * @param {CompileOptions} options - Compilation options.
-     * @param {string} outDir - The directory to save the compiled artifacts.
-     * @returns {string[]} The arguments to compile the circuit.
-     */
-    _getCompileArgs(options, outDir) {
-        let args = [this._circuit, "--r1cs", "--wasm"];
-        options.sym && args.push("--sym");
-        options.json && args.push("--json");
-        options.c && args.push("--c");
-        args.push("-o", outDir);
-        return args;
-    }
-    /**
-     * Compiles the circuit.
-     *
-     * @param {CompileOptions} options - Compilation options.
-     * @param {string} outDir - The directory to save the compiled artifacts.
-     */
-    async _compile(options, outDir) {
-        const args = this._getCompileArgs(options, outDir);
-        try {
-            await this._getCircomRunner(args, options.quiet).execute(this._manager.getCompiler());
-        }
-        catch (err) {
-            if (options.quiet) {
-                throw new Error('Compilation failed with an unknown error. Consider passing "quiet=false" flag to see the compilation error.', { cause: err });
-            }
-            throw new Error("Compilation failed.", { cause: err });
-        }
-    }
-    /**
-     * Returns the number of constraints in the circuit. This value is used to fetch the correct `ptau` file.
-     *
-     * @param {string} outDir - The directory where the compiled artifacts are saved.
-     * @returns {Promise<number>} The number of constraints in the circuit.
+     * @param {ArtifactsFileType} fileType - The type of the file.
+     * @returns {string} The path to the file.
      */
-    async _getConstraints(outDir) {
-        const r1csFile = this._getFile("r1cs", outDir);
-        const r1csDescriptor = fs_1.default.openSync(r1csFile, "r");
-        const readBytes = (position, length) => {
-            const buffer = Buffer.alloc(length);
-            fs_1.default.readSync(r1csDescriptor, buffer, { length, position });
-            return BigInt(`0x${buffer.reverse().toString("hex")}`);
-        };
-        /// @dev https://github.com/iden3/r1csfile/blob/d82959da1f88fbd06db0407051fde94afbf8824a/doc/r1cs_bin_format.md#format-of-the-file
-        const numberOfSections = readBytes(8, 4);
-        let sectionStart = 12;
-        for (let i = 0; i < numberOfSections; ++i) {
-            const sectionType = Number(readBytes(sectionStart, 4));
-            const sectionSize = Number(readBytes(sectionStart + 4, 8));
-            /// @dev Reading header section
-            if (sectionType == 1) {
-                const totalConstraintsOffset = 4 + 8 + 4 + 32 + 4 + 4 + 4 + 4 + 8;
-                return Number(readBytes(sectionStart + totalConstraintsOffset, 4));
-            }
-            sectionStart += 4 + 8 + sectionSize;
+    mustGetArtifactsFilePath(fileType) {
+        const file = this.getArtifactsFilePath(fileType);
+        if (!fs_1.default.existsSync(file)) {
+            throw new Error(`Expected the file "${file}" to exist`);
         }
-        throw new Error("Header section is not found.");
+        return file;
     }
     /**
-     * Returns the path to the file of the given type.
+     * Returns the path to the file of the given type inside artifacts directory.
      *
-     * @param {FileType} fileType - The type of the file.
-     * @param {string | undefined} temp - The temporary directory to use.
+     * @param {ArtifactsFileType} fileType - The type of the file.
      * @returns {string} The path to the file.
      */
-    _getFile(fileType, temp) {
-        const circuitId = this.getCircuitId();
+    getArtifactsFilePath(fileType) {
+        const circuitName = this.getCircuitName();
+        let fileName;
+        let fileDir = this._config.circuitArtifactsPath;
         switch (fileType) {
             case "r1cs":
-                return path_1.default.join(temp ?? this._getDir("artifact"), `${circuitId}.r1cs`);
+                fileName = `${circuitName}.r1cs`;
+                break;
             case "zkey":
-                return path_1.default.join(temp ?? this._getDir("artifact"), `${circuitId}.zkey`);
+                fileName = `${circuitName}.zkey`;
+                break;
             case "vkey":
-                return path_1.default.join(temp ?? this._getDir("artifact"), `${circuitId}.vkey.json`);
+                fileName = `${circuitName}.vkey.json`;
+                break;
             case "sym":
-                return path_1.default.join(temp ?? this._getDir("artifact"), `${circuitId}.sym`);
+                fileName = `${circuitName}.sym`;
+                break;
             case "json":
-                return path_1.default.join(temp ?? this._getDir("artifact"), `${circuitId}.json`);
+                fileName = `${circuitName}_constraints.json`;
+                break;
             case "wasm":
-                return path_1.default.join(temp ?? this._getDir("artifact"), `${circuitId}_js`, `${circuitId}.wasm`);
-            case "sol":
-                return path_1.default.join(temp ?? this._getDir("verifier"), `${circuitId}Verifier.sol`);
+                fileName = `${circuitName}.wasm`;
+                fileDir = path_1.default.join(fileDir, `${circuitName}_js`);
+                break;
             default:
                 throw new Error(`Ambiguous file type: ${fileType}.`);
         }
-    }
-    /**
-     * Returns the path to the directory of the given type.
-     *
-     * @param {DirType} dirType - The type of the directory.
-     * @returns {string} The path to the directory.
-     */
-    _getDir(dirType) {
-        const circuitRelativePath = path_1.default.relative(this._manager.getCircuitsDir(), this._circuit);
-        switch (dirType) {
-            case "circuit":
-                return path_1.default.join(this._manager.getCircuitsDir(), circuitRelativePath, "..");
-            case "artifact":
-                return path_1.default.join(this._manager.getArtifactsDir(), circuitRelativePath);
-            case "verifier":
-                return path_1.default.join(this._manager.getVerifiersDir(), circuitRelativePath, "..");
-            default:
-                throw new Error(`Ambiguous dir type: ${dirType}.`);
-        }
-    }
-    /**
-     * Returns the path to the file of the given type. Throws an error if the file doesn't exist.
-     *
-     * @param {FileType} fileType - The type of the file.
-     * @param {string | undefined} temp - The temporary directory to use.
-     * @returns {string} The path to the file.
-     */
-    _mustGetFile(fileType, temp) {
-        const file = this._getFile(fileType, temp);
-        if (!fs_1.default.existsSync(file)) {
-            throw new Error(`Expected the file "${file}" to exist`);
-        }
-        return file;
-    }
-    /**
-     * Moves the files from the temporary directory to the output directory.
-     *
-     * @param {string} tempDir - The temporary directory.
-     * @param {string} outDir - The output directory.
-     */
-    _moveFromTempDirToOutDir(tempDir, outDir) {
-        fs_1.default.mkdirSync(outDir, { recursive: true });
-        (0, utils_1.readDirRecursively)(tempDir, (dir, file) => {
-            const correspondingOutDir = path_1.default.join(outDir, path_1.default.relative(tempDir, dir));
-            const correspondingOutFile = path_1.default.join(outDir, path_1.default.relative(tempDir, file));
-            if (!fs_1.default.existsSync(correspondingOutDir)) {
-                fs_1.default.mkdirSync(correspondingOutDir);
-            }
-            if (fs_1.default.existsSync(correspondingOutFile)) {
-                fs_1.default.rmSync(correspondingOutFile);
-            }
-            fs_1.default.copyFileSync(file, correspondingOutFile);
-        });
-    }
-    /**
-     * Returns a new instance of `CircomRunner`. The `CircomRunner` is used to compile the circuit.
-     *
-     * @param {string[]} args - The arguments to run the `circom` compiler.
-     * @param {boolean} quiet - Whether to suppress the compilation error.
-     * @returns {typeof CircomRunner} The `CircomRunner` instance.
-     */
-    _getCircomRunner(args, quiet) {
-        return new CircomRunner({
-            args,
-            preopens: { "/": "/" },
-            bindings: {
-                ...bindings,
-                exit(code) {
-                    throw new Error(`Compilation error. Exit code: ${code}.`);
-                },
-                fs: fs_1.default,
-            },
-            quiet,
-        });
+        return path_1.default.join(fileDir, fileName);
     }
 }
 exports.CircuitZKit = CircuitZKit;