@solarity/zkit 0.1.0 → 0.2.0

package/src/core/CircuitZKit.ts

@@ -3,86 +3,55 @@ import fs from "fs";
 import path from "path";
 import * as snarkjs from "snarkjs";
 
-import { defaultCompileOptions, CompileOptions } from "../config/config";
-import { ManagerZKit } from "./ManagerZKit";
-import { Calldata, DirType, FileType, Inputs, ProofStruct } from "../types/types";
-import { readDirRecursively } from "../utils/utils";
-
-const { CircomRunner, bindings } = require("@distributedlab/circom2");
+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 class CircuitZKit {
-  /**
-   * 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(
-    private readonly _circuit: string,
-    private readonly _manager: ManagerZKit,
-  ) {}
+  constructor(private readonly _config: CircuitZKitConfig) {}
 
   /**
-   * 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.
    */
-  public async compile(options: Partial<CompileOptions> = defaultCompileOptions): Promise<void> {
-    const tempDir = this._manager.getTempDir();
-
-    try {
-      const artifactDir = this._getDir("artifact");
-
-      fs.mkdirSync(tempDir, { recursive: true });
-
-      const overriddenOptions: CompileOptions = { ...defaultCompileOptions, ...options };
-
-      await this._compile(overriddenOptions, tempDir);
-
-      await this._generateZKey(tempDir);
-      await this._generateVKey(tempDir);
-
-      this._moveFromTempDirToOutDir(tempDir, artifactDir);
-    } finally {
-      fs.rmSync(tempDir, { recursive: true, force: true });
+  public static getTemplate(templateType: VerifierTemplateType): string {
+    switch (templateType) {
+      case "groth16":
+        return fs.readFileSync(path.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.
    */
   public async createVerifier(): Promise<void> {
-    const tempDir = this._manager.getTempDir();
-
-    try {
-      const verifierDir = this._getDir("verifier");
-
-      fs.mkdirSync(tempDir, { recursive: true });
+    const vKeyFilePath: string = this.mustGetArtifactsFilePath("vkey");
+    const verifierFilePath = path.join(this._config.verifierDirPath, `${this.getVerifierName()}.sol`);
 
-      const vKeyFile = this._mustGetFile("vkey");
-      const verifierFile = this._getFile("sol", tempDir);
+    const verifierTemplate: string = CircuitZKit.getTemplate(this.getTemplateType());
 
-      const groth16Template = this._manager.getTemplate("groth16");
-
-      const templateParams = JSON.parse(fs.readFileSync(vKeyFile, "utf-8"));
-      templateParams["verifier_id"] = this.getVerifierId();
+    if (!fs.existsSync(this._config.verifierDirPath)) {
+      fs.mkdirSync(this._config.verifierDirPath, { recursive: true });
+    }
 
-      const verifierCode = ejs.render(groth16Template, templateParams);
+    const templateParams = JSON.parse(fs.readFileSync(vKeyFilePath, "utf-8"));
+    templateParams["verifier_id"] = this.getVerifierName();
 
-      fs.writeFileSync(verifierFile, verifierCode, "utf-8");
+    const verifierCode = ejs.render(verifierTemplate, templateParams);
 
-      this._moveFromTempDirToOutDir(tempDir, verifierDir);
-    } finally {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
+    fs.writeFileSync(verifierFilePath, verifierCode, "utf-8");
   }
 
   /**
@@ -95,8 +64,8 @@ export class CircuitZKit {
    * @todo Add support for other proving systems.
    */
   public async generateProof(inputs: Inputs): Promise<ProofStruct> {
-    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)) as ProofStruct;
   }
@@ -111,7 +80,7 @@ export class CircuitZKit {
    * @returns {Promise<boolean>} Whether the proof is valid.
    */
   public async verifyProof(proof: ProofStruct): Promise<boolean> {
-    const vKeyFile = this._mustGetFile("vkey");
+    const vKeyFile = this.mustGetArtifactsFilePath("vkey");
 
     const verifier = JSON.parse(fs.readFileSync(vKeyFile).toString());
 
@@ -132,244 +101,84 @@ export class CircuitZKit {
   }
 
   /**
-   * Returns the circuit ID. The circuit ID is the name of the circuit file without the extension.
-   *
-   * @returns {string} The circuit ID.
-   */
-  public getCircuitId(): string {
-    return path.parse(this._circuit).name;
-  }
-
-  /**
-   * Returns the verifier ID. The verifier ID is the name of the circuit file without the extension, suffixed with "Verifier".
+   * Returns the circuit name. The circuit name is the name of the circuit file without the extension.
    *
-   * @returns {string} The verifier ID.
+   * @returns {string} The circuit name.
    */
-  public getVerifierId(): string {
-    return `${path.parse(this._circuit).name}Verifier`;
+  public getCircuitName(): string {
+    return this._config.circuitName;
   }
 
   /**
-   * Generates zero-knowledge key for the circuit.
+   * Returns the verifier name. The verifier name is the name of the circuit file without the extension, suffixed with "Verifier".
    *
-   * @param {string} outDir - The directory to save the generated key.
-   * @todo This method may cause issues https://github.com/iden3/snarkjs/issues/494
+   * @returns {string} The verifier name.
    */
-  private async _generateZKey(outDir: string): Promise<void> {
-    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);
-
-    await snarkjs.zKey.newZKey(r1csFile, ptauFile, zKeyFile);
-  }
-
-  /**
-   * Generates verification key for the circuit.
-   *
-   * @param {string} outDir - The directory to save the generated key.
-   */
-  private async _generateVKey(outDir: string): Promise<void> {
-    const zKeyFile = this._getFile("zkey", outDir);
-    const vKeyFile = this._getFile("vkey", outDir);
-
-    const vKeyData = await snarkjs.zKey.exportVerificationKey(zKeyFile);
-
-    fs.writeFileSync(vKeyFile, JSON.stringify(vKeyData));
-  }
-
-  /**
-   * Returns the arguments to compile the circuit.
-   *
-   * @param {CompileOptions} options - Compilation options.
-   * @param {string} outDir - The directory to save the compiled artifacts.
-   * @returns {string[]} The arguments to compile the circuit.
-   */
-  private _getCompileArgs(options: CompileOptions, outDir: string): string[] {
-    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;
+  public getVerifierName(): string {
+    return `${this._config.circuitName}Verifier`;
   }
 
   /**
-   * 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 async _compile(options: CompileOptions, outDir: string): Promise<void> {
-    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 });
-    }
+  public getTemplateType(): VerifierTemplateType {
+    return this._config.templateType ?? "groth16";
   }
 
   /**
-   * 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.
+   * @param {ArtifactsFileType} fileType - The type of the file.
+   * @returns {string} The path to the file.
    */
-  async _getConstraints(outDir: string): Promise<number> {
-    const r1csFile = this._getFile("r1cs", outDir);
-
-    const r1csDescriptor = fs.openSync(r1csFile, "r");
+  public mustGetArtifactsFilePath(fileType: ArtifactsFileType): string {
+    const file = this.getArtifactsFilePath(fileType);
 
-    const readBytes = (position: number, length: number): bigint => {
-      const buffer = Buffer.alloc(length);
-
-      fs.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;
+    if (!fs.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.
    */
-  private _getFile(fileType: FileType, temp?: string): string {
-    const circuitId = this.getCircuitId();
+  public getArtifactsFilePath(fileType: ArtifactsFileType): string {
+    const circuitName = this.getCircuitName();
+
+    let fileName: string;
+    let fileDir: string = this._config.circuitArtifactsPath;
 
     switch (fileType) {
       case "r1cs":
-        return path.join(temp ?? this._getDir("artifact"), `${circuitId}.r1cs`);
+        fileName = `${circuitName}.r1cs`;
+        break;
       case "zkey":
-        return path.join(temp ?? this._getDir("artifact"), `${circuitId}.zkey`);
+        fileName = `${circuitName}.zkey`;
+        break;
       case "vkey":
-        return path.join(temp ?? this._getDir("artifact"), `${circuitId}.vkey.json`);
+        fileName = `${circuitName}.vkey.json`;
+        break;
       case "sym":
-        return path.join(temp ?? this._getDir("artifact"), `${circuitId}.sym`);
+        fileName = `${circuitName}.sym`;
+        break;
       case "json":
-        return path.join(temp ?? this._getDir("artifact"), `${circuitId}.json`);
+        fileName = `${circuitName}_constraints.json`;
+        break;
       case "wasm":
-        return path.join(temp ?? this._getDir("artifact"), `${circuitId}_js`, `${circuitId}.wasm`);
-      case "sol":
-        return path.join(temp ?? this._getDir("verifier"), `${circuitId}Verifier.sol`);
+        fileName = `${circuitName}.wasm`;
+        fileDir = path.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.
-   */
-  private _getDir(dirType: DirType): string {
-    const circuitRelativePath = path.relative(this._manager.getCircuitsDir(), this._circuit);
 
-    switch (dirType) {
-      case "circuit":
-        return path.join(this._manager.getCircuitsDir(), circuitRelativePath, "..");
-      case "artifact":
-        return path.join(this._manager.getArtifactsDir(), circuitRelativePath);
-      case "verifier":
-        return path.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.
-   */
-  private _mustGetFile(fileType: FileType, temp?: string): string {
-    const file = this._getFile(fileType, temp);
-
-    if (!fs.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.
-   */
-  private _moveFromTempDirToOutDir(tempDir: string, outDir: string): void {
-    fs.rmSync(outDir, { recursive: true, force: true });
-    fs.mkdirSync(outDir, { recursive: true });
-
-    readDirRecursively(tempDir, (dir: string, file: string) => {
-      const correspondingOutDir = path.join(outDir, path.relative(tempDir, dir));
-      const correspondingOutFile = path.join(outDir, path.relative(tempDir, file));
-
-      if (!fs.existsSync(correspondingOutDir)) {
-        fs.mkdirSync(correspondingOutDir);
-      }
-
-      fs.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.
-   */
-  private _getCircomRunner(args: string[], quiet: boolean): typeof CircomRunner {
-    return new CircomRunner({
-      args,
-      preopens: { "/": "/" },
-      bindings: {
-        ...bindings,
-        exit(code: number) {
-          throw new Error(`Compilation error. Exit code: ${code}.`);
-        },
-        fs,
-      },
-      quiet,
-    });
+    return path.join(fileDir, fileName);
   }
 }

package/src/index.ts

@@ -1,7 +1,2 @@
-export * from "./core/CircomZKit";
 export * from "./core/CircuitZKit";
-export * from "./core/ManagerZKit";
-
-export { NumericString, PublicSignals, Groth16Proof, Calldata, ProofStruct, Inputs, CircuitInfo } from "./types/types";
-
-export { CompileOptions, ManagerZKitConfig, defaultCompileOptions, defaultManagerOptions } from "./config/config";
+export * from "./types/circuit-zkit";

package/src/types/{types.ts → circuit-zkit.ts}

@@ -28,16 +28,12 @@ export type InputLike = NumberLike | ArrayLike;
 
 export type Inputs = Record<string, InputLike>;
 
-export type CircuitInfo = {
-  path: string;
-  id: string | null;
-};
-
-export type FileType = "r1cs" | "zkey" | "vkey" | "sym" | "json" | "wasm" | "sol";
-export type DirType = "circuit" | "artifact" | "verifier";
-export type TemplateType = "groth16";
-
-export type PtauInfo = {
-  file: string;
-  url: string | null;
+export type ArtifactsFileType = "r1cs" | "zkey" | "vkey" | "sym" | "json" | "wasm";
+export type VerifierTemplateType = "groth16";
+
+export type CircuitZKitConfig = {
+  circuitName: string;
+  circuitArtifactsPath: string;
+  verifierDirPath: string;
+  templateType?: VerifierTemplateType;
 };

package/src/config/config.ts

@@ -1,37 +0,0 @@
-const { Context } = require("@distributedlab/circom2");
-
-export type ManagerZKitConfig = {
-  circuitsDir: string;
-  artifactsDir: string;
-  verifiersDir: string;
-  ptauDir: string;
-  allowDownload: boolean;
-};
-
-export const defaultManagerOptions: Partial<ManagerZKitConfig> = {
-  circuitsDir: "circuits",
-  artifactsDir: "zkit-artifacts",
-  verifiersDir: "contracts/verifiers",
-  allowDownload: true,
-};
-
-export type CompileOptions = {
-  sym: boolean;
-  json: boolean;
-  c: boolean;
-  quiet: boolean;
-};
-
-export const defaultCompileOptions: CompileOptions = {
-  sym: false,
-  json: false,
-  c: false,
-  quiet: false,
-};
-
-export type ManagerZKitPrivateConfig = ManagerZKitConfig & {
-  compiler: typeof Context;
-  templates: {
-    groth16: string;
-  };
-};

package/src/core/CircomZKit.ts

@@ -1,110 +0,0 @@
-import os from "os";
-import path from "path";
-
-import { CircuitZKit } from "./CircuitZKit";
-import { ManagerZKit } from "./ManagerZKit";
-import { CircuitInfo } from "../types/types";
-import { readDirRecursively } from "../utils/utils";
-import { defaultManagerOptions, ManagerZKitConfig } from "../config/config";
-
-/**
- * `CircomZKit` acts as a factory for `CircuitZKit` instances.
- */
-export class CircomZKit {
-  private readonly _manager: ManagerZKit;
-
-  /**
-   * Creates a new `CircomZKit` instance.
-   *
-   * @param {Partial<ManagerZKitConfig>} [options=defaultManagerOptions] - The configuration options to use.
-   */
-  constructor(options: Partial<ManagerZKitConfig> = defaultManagerOptions) {
-    this._manager = new ManagerZKit({ ...defaultManagerOptions, ...options });
-  }
-
-  /**
-   * Returns a `CircuitZKit` instance for the specified circuit.
-   *
-   * @dev If the circuit id is not unique, the path to the circuit file must be provided.
-   *
-   * @param {string} circuit - The path to the circuit file or the circuit id (filename without extension).
-   * @returns {CircomZKit} The `CircuitZKit` instance.
-   */
-  public getCircuit(circuit: string): CircuitZKit {
-    const circuits = this._getAllCircuits();
-
-    const candidates = circuits.filter((file) => {
-      if (circuit.endsWith(".circom")) {
-        return file == path.normalize(circuit);
-      }
-
-      return path.basename(file) == `${circuit}.circom`;
-    });
-
-    if (candidates.length == 0) {
-      throw Error(`No circuits with name \"${circuit}\" found`);
-    }
-
-    if (candidates.length > 1) {
-      throw Error(
-        `Found multiple entries for the circuit "${circuit}".
-
-        \rConsider replacing \"${circuit}\" with one of the valid paths:
-        \r${candidates.map((candidate) => `"${candidate}"`).join(os.EOL)}`,
-      );
-    }
-
-    return new CircuitZKit(path.join(this._manager.getCircuitsDir(), candidates[0]), this._manager);
-  }
-
-  /**
-   * Returns an array of all circuits available in the circuits directory.
-   *
-   * @dev If a circuit id is not unique, the id will be set to `null`.
-   *
-   * @returns {CircuitInfo[]} An array of circuit information objects.
-   */
-  public getCircuits(): CircuitInfo[] {
-    const circuits = this._getAllCircuits();
-
-    let circuitsCount = {} as Record<string, number>;
-
-    for (const circuit of circuits) {
-      const circuitId = path.parse(circuit).name;
-
-      circuitsCount[circuitId] = (circuitsCount[circuitId] || 0) + 1;
-    }
-
-    let result = [] as CircuitInfo[];
-
-    for (const circuit of circuits) {
-      const circuitId = path.parse(circuit).name;
-
-      result.push({
-        path: circuit,
-        id: circuitsCount[circuitId] > 1 ? null : circuitId,
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Returns an array of all circuits paths available in the circuits directory.
-   *
-   * @returns {string[]} An array of circuit paths.
-   */
-  private _getAllCircuits(): string[] {
-    const circuitsDir = this._manager.getCircuitsDir();
-
-    let circuits = [] as string[];
-
-    readDirRecursively(circuitsDir, (_dir: string, file: string) => {
-      if (path.extname(file) == ".circom") {
-        circuits.push(path.relative(circuitsDir, file));
-      }
-    });
-
-    return circuits;
-  }
-}