@solarity/zkit 0.2.6 → 0.3.0-rc.1

package/dist/types/circuit-zkit.d.ts

@@ -1,42 +1,8 @@
-export type NumericString = `${number}` | string;
-export type PublicSignals = NumericString[];
-export type Groth16Proof = {
-    pi_a: [NumericString, NumericString];
-    pi_b: [[NumericString, NumericString], [NumericString, NumericString]];
-    pi_c: [NumericString, NumericString];
-    protocol: string;
-    curve: string;
-};
-export type Calldata = [
-    [
-        NumericString,
-        NumericString
-    ],
-    [
-        [NumericString, NumericString],
-        [NumericString, NumericString]
-    ],
-    [
-        NumericString,
-        NumericString
-    ],
-    PublicSignals
-];
-export type ProofStruct = {
-    proof: Groth16Proof;
-    publicSignals: PublicSignals;
-};
-export type NumberLike = number | bigint | `${number}`;
-export type ArrayLike = NumberLike[] | ArrayLike[];
-export type Signal = NumberLike | ArrayLike;
-export type Signals = Record<string, Signal>;
 export type ArtifactsFileType = "r1cs" | "zkey" | "vkey" | "sym" | "json" | "wasm";
-export type VerifierProvingSystem = "groth16";
 export type VerifierLanguageType = "sol" | "vy";
 export type CircuitZKitConfig = {
     circuitName: string;
     circuitArtifactsPath: string;
     verifierDirPath: string;
-    provingSystem?: VerifierProvingSystem;
 };
 //# sourceMappingURL=circuit-zkit.d.ts.map

package/dist/types/circuit-zkit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circuit-zkit.d.ts","sourceRoot":"","sources":["../../src/types/circuit-zkit.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC;AAEjD,MAAM,MAAM,aAAa,GAAG,aAAa,EAAE,CAAC;AAE5C,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACrC,IAAI,EAAE,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC,CAAC;IACvE,IAAI,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB;QAAC,aAAa;QAAE,aAAa;KAAC;IAC9B;QAAC,CAAC,aAAa,EAAE,aAAa,CAAC;QAAE,CAAC,aAAa,EAAE,aAAa,CAAC;KAAC;IAChE;QAAC,aAAa;QAAE,aAAa;KAAC;IAC9B,aAAa;CACd,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,YAAY,CAAC;IACpB,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;AACvD,MAAM,MAAM,SAAS,GAAG,UAAU,EAAE,GAAG,SAAS,EAAE,CAAC;AACnD,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAC5C,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AACnF,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC;AAC9C,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,IAAI,CAAC;AAEhD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,qBAAqB,CAAC;CACvC,CAAC"}
+{"version":3,"file":"circuit-zkit.d.ts","sourceRoot":"","sources":["../../src/types/circuit-zkit.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AACnF,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,IAAI,CAAC;AAEhD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC"}

package/dist/types/proof-utils.d.ts

@@ -0,0 +1,7 @@
+export type NumericString = `${number}` | string;
+export type PublicSignals = NumericString[];
+export type NumberLike = number | bigint | `${number}`;
+export type ArrayLike = NumberLike[] | ArrayLike[];
+export type Signal = NumberLike | ArrayLike;
+export type Signals = Record<string, Signal>;
+//# sourceMappingURL=proof-utils.d.ts.map

package/dist/types/proof-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-utils.d.ts","sourceRoot":"","sources":["../../src/types/proof-utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC;AAEjD,MAAM,MAAM,aAAa,GAAG,aAAa,EAAE,CAAC;AAE5C,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;AACvD,MAAM,MAAM,SAAS,GAAG,UAAU,EAAE,GAAG,SAAS,EAAE,CAAC;AAEnD,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAC5C,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC"}

package/dist/types/proof-utils.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=proof-utils.js.map

package/dist/types/proof-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-utils.js","sourceRoot":"","sources":["../../src/types/proof-utils.ts"],"names":[],"mappings":""}

package/dist/types/protocols/groth16.d.ts

@@ -0,0 +1,28 @@
+import { NumericString, PublicSignals } from "../proof-utils";
+export interface Groth16Proof {
+    pi_a: [NumericString, NumericString];
+    pi_b: [[NumericString, NumericString], [NumericString, NumericString]];
+    pi_c: [NumericString, NumericString];
+    protocol: string;
+    curve: string;
+}
+export interface Groth16ProofStruct {
+    proof: Groth16Proof;
+    publicSignals: PublicSignals;
+}
+export type Groth16Calldata = [
+    [
+        NumericString,
+        NumericString
+    ],
+    [
+        [NumericString, NumericString],
+        [NumericString, NumericString]
+    ],
+    [
+        NumericString,
+        NumericString
+    ],
+    PublicSignals
+];
+//# sourceMappingURL=groth16.d.ts.map

package/dist/types/protocols/groth16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groth16.d.ts","sourceRoot":"","sources":["../../../src/types/protocols/groth16.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE9D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACrC,IAAI,EAAE,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC,CAAC;IACvE,IAAI,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,YAAY,CAAC;IACpB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B;QAAC,aAAa;QAAE,aAAa;KAAC;IAC9B;QAAC,CAAC,aAAa,EAAE,aAAa,CAAC;QAAE,CAAC,aAAa,EAAE,aAAa,CAAC;KAAC;IAChE;QAAC,aAAa;QAAE,aAAa;KAAC;IAC9B,aAAa;CACd,CAAC"}

package/dist/types/protocols/groth16.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=groth16.js.map

package/dist/types/protocols/groth16.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"groth16.js","sourceRoot":"","sources":["../../../src/types/protocols/groth16.ts"],"names":[],"mappings":""}

package/dist/types/protocols/index.d.ts

@@ -0,0 +1,31 @@
+import { Groth16ProofStruct, Groth16Calldata } from "./groth16";
+import { PlonkProofStruct, PlonkCalldata } from "./plonk";
+import { Signals } from "../proof-utils";
+import { VerifierLanguageType } from "../circuit-zkit";
+export * from "./groth16";
+export * from "./plonk";
+export interface IProtocolImplementer<T extends ProvingSystemType> {
+    createVerifier(circuitName: string, vKeyFilePath: string, verifierFilePath: string, languageExtension: VerifierLanguageType): Promise<void>;
+    generateProof(inputs: Signals, zKeyFilePath: string, wasmFilePath: string): Promise<ProofStructByProtocol<T>>;
+    verifyProof(proof: ProofStructByProtocol<T>, vKeyFilePath: string): Promise<boolean>;
+    generateCalldata(proof: ProofStructByProtocol<T>): Promise<CalldataByProtocol<T>>;
+    getProvingSystemType(): ProvingSystemType;
+    getTemplate(fileExtension: VerifierLanguageType): string;
+    getVerifierName(circuitName: string): string;
+    getZKeyFileName(circuitName: string): string;
+    getVKeyFileName(circuitName: string): string;
+}
+export interface ProvingSystemStructMap {
+    groth16: {
+        proofStruct: Groth16ProofStruct;
+        calldata: Groth16Calldata;
+    };
+    plonk: {
+        proofStruct: PlonkProofStruct;
+        calldata: PlonkCalldata;
+    };
+}
+export type ProvingSystemType = keyof ProvingSystemStructMap;
+export type ProofStructByProtocol<T extends ProvingSystemType> = ProvingSystemStructMap[T]["proofStruct"];
+export type CalldataByProtocol<T extends ProvingSystemType> = ProvingSystemStructMap[T]["calldata"];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/protocols/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/protocols/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE1D,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AAExB,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,iBAAiB;IAC/D,cAAc,CACZ,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,iBAAiB,EAAE,oBAAoB,GACtC,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9G,WAAW,CAAC,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAErF,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;IAElF,oBAAoB,IAAI,iBAAiB,CAAC;IAE1C,WAAW,CAAC,aAAa,EAAE,oBAAoB,GAAG,MAAM,CAAC;IAEzD,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAE7C,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAE7C,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9C;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE;QACP,WAAW,EAAE,kBAAkB,CAAC;QAChC,QAAQ,EAAE,eAAe,CAAC;KAC3B,CAAC;IACF,KAAK,EAAE;QACL,WAAW,EAAE,gBAAgB,CAAC;QAC9B,QAAQ,EAAE,aAAa,CAAC;KACzB,CAAC;CACH;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,sBAAsB,CAAC;AAE7D,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,iBAAiB,IAAI,sBAAsB,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;AAC1G,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,iBAAiB,IAAI,sBAAsB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC"}

package/dist/types/protocols/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./groth16"), exports);
+__exportStar(require("./plonk"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/protocols/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/protocols/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAMA,4CAA0B;AAC1B,0CAAwB"}

package/dist/types/protocols/plonk.d.ts

@@ -0,0 +1,26 @@
+import { NumericString, PublicSignals } from "../proof-utils";
+export interface PlonkProof {
+    A: [NumericString, NumericString];
+    B: [NumericString, NumericString];
+    C: [NumericString, NumericString];
+    Z: [NumericString, NumericString];
+    T1: [NumericString, NumericString];
+    T2: [NumericString, NumericString];
+    T3: [NumericString, NumericString];
+    Wxi: [NumericString, NumericString];
+    Wxiw: [NumericString, NumericString];
+    eval_a: NumericString;
+    eval_b: NumericString;
+    eval_c: NumericString;
+    eval_s1: NumericString;
+    eval_s2: NumericString;
+    eval_zw: NumericString;
+    protocol: string;
+    curve: string;
+}
+export interface PlonkProofStruct {
+    proof: PlonkProof;
+    publicSignals: PublicSignals;
+}
+export type PlonkCalldata = [NumericString[], PublicSignals];
+//# sourceMappingURL=plonk.d.ts.map

package/dist/types/protocols/plonk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plonk.d.ts","sourceRoot":"","sources":["../../../src/types/protocols/plonk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE9D,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IAClC,CAAC,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IAClC,CAAC,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IAClC,CAAC,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IAClC,EAAE,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACnC,EAAE,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACnC,EAAE,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACnC,GAAG,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACpC,IAAI,EAAE,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;IACrC,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,UAAU,CAAC;IAClB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,aAAa,EAAE,EAAE,aAAa,CAAC,CAAC"}

package/dist/types/{types.js → protocols/plonk.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=plonk.js.map

package/dist/types/protocols/plonk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plonk.js","sourceRoot":"","sources":["../../../src/types/protocols/plonk.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solarity/zkit",
-  "version": "0.2.6",
+  "version": "0.3.0-rc.1",
   "license": "MIT",
   "author": "Distributed Lab",
   "readme": "README.md",

package/src/core/CircuitZKit.ts

@@ -1,60 +1,32 @@
-import ejs from "ejs";
 import fs from "fs";
-import * as os from "os";
 import path from "path";
+import * as os from "os";
 import * as snarkjs from "snarkjs";
 
-import {
-  ArtifactsFileType,
-  Calldata,
-  CircuitZKitConfig,
-  Signals,
-  ProofStruct,
-  VerifierProvingSystem,
-  VerifierLanguageType,
-} from "../types/circuit-zkit";
+import { ArtifactsFileType, CircuitZKitConfig, VerifierLanguageType } from "../types/circuit-zkit";
+import { Signals } from "../types/proof-utils";
+import { CalldataByProtocol, IProtocolImplementer, ProofStructByProtocol, ProvingSystemType } from "../types/protocols";
 
 /**
  * `CircuitZKit` represents a single circuit and provides a high-level API to work with it.
  */
-export class CircuitZKit {
-  constructor(private readonly _config: CircuitZKitConfig) {}
-
-  /**
-   * Returns the verifier template for the specified proving system and contract language.
-   *
-   * @param {VerifierProvingSystem} provingSystem - The template proving system.
-   * @param {VerifierLanguageType} fileExtension - The file extension.
-   * @returns {string} The verifier template.
-   */
-  public static getTemplate(provingSystem: VerifierProvingSystem, fileExtension: VerifierLanguageType): string {
-    switch (provingSystem) {
-      case "groth16":
-        return fs.readFileSync(path.join(__dirname, "templates", `verifier_groth16.${fileExtension}.ejs`), "utf8");
-      default:
-        throw new Error(`Ambiguous proving system: ${provingSystem}.`);
-    }
-  }
+export class CircuitZKit<Type extends ProvingSystemType> {
+  constructor(
+    private readonly _config: CircuitZKitConfig,
+    private readonly _implementer: IProtocolImplementer<Type>,
+  ) {}
 
   /**
    * Creates a verifier contract for the specified contract language.
    */
   public async createVerifier(languageExtension: VerifierLanguageType): Promise<void> {
     const vKeyFilePath: string = this.mustGetArtifactsFilePath("vkey");
-    const verifierFilePath = path.join(this._config.verifierDirPath, `${this.getVerifierName()}.${languageExtension}`);
+    const verifierFilePath = path.join(
+      this._config.verifierDirPath,
+      `${this._implementer.getVerifierName(this._config.circuitName)}.${languageExtension}`,
+    );
 
-    const verifierTemplate: string = CircuitZKit.getTemplate(this.getProvingSystem(), languageExtension);
-
-    if (!fs.existsSync(this._config.verifierDirPath)) {
-      fs.mkdirSync(this._config.verifierDirPath, { recursive: true });
-    }
-
-    const templateParams = JSON.parse(fs.readFileSync(vKeyFilePath, "utf-8"));
-    templateParams["verifier_id"] = this.getVerifierName();
-
-    const verifierCode = ejs.render(verifierTemplate, templateParams);
-
-    fs.writeFileSync(verifierFilePath, verifierCode, "utf-8");
+    this._implementer.createVerifier(this._config.circuitName, vKeyFilePath, verifierFilePath, languageExtension);
   }
 
   /**
@@ -84,14 +56,14 @@ export class CircuitZKit {
    * @dev The `inputs` should be in the same order as the circuit expects them.
    *
    * @param {Signals} inputs - The inputs for the circuit.
-   * @returns {Promise<ProofStruct>} The generated proof.
+   * @returns {Promise<ProofStructByProtocol<Type>>} The generated proof.
    * @todo Add support for other proving systems.
    */
-  public async generateProof(inputs: Signals): Promise<ProofStruct> {
+  public async generateProof(inputs: Signals): Promise<ProofStructByProtocol<Type>> {
     const zKeyFile = this.mustGetArtifactsFilePath("zkey");
     const wasmFile = this.mustGetArtifactsFilePath("wasm");
 
-    return (await snarkjs.groth16.fullProve(inputs, wasmFile, zKeyFile)) as ProofStruct;
+    return await this._implementer.generateProof(inputs, zKeyFile, wasmFile);
   }
 
   /**
@@ -100,28 +72,24 @@ export class CircuitZKit {
    * @dev The `proof` can be generated using the `generateProof` method.
    * @dev The `proof.publicSignals` should be in the same order as the circuit expects them.
    *
-   * @param {ProofStruct} proof - The proof to verify.
+   * @param {ProofStructByProtocol<Type>} proof - The proof to verify.
    * @returns {Promise<boolean>} Whether the proof is valid.
    */
-  public async verifyProof(proof: ProofStruct): Promise<boolean> {
+  public async verifyProof(proof: ProofStructByProtocol<Type>): Promise<boolean> {
     const vKeyFile = this.mustGetArtifactsFilePath("vkey");
 
-    const verifier = JSON.parse(fs.readFileSync(vKeyFile).toString());
-
-    return await snarkjs.groth16.verify(verifier, proof.publicSignals, proof.proof);
+    return this._implementer.verifyProof(proof, vKeyFile);
   }
 
   /**
    * Generates the calldata for the given proof. The calldata can be used to verify the proof on-chain.
    *
-   * @param {ProofStruct} proof - The proof to generate calldata for.
-   * @returns {Promise<Calldata>} - The generated calldata.
+   * @param {ProofStructByProtocol<Type>} proof - The proof to generate calldata for.
+   * @returns {Promise<CalldataByProtocol<Type>>} - The generated calldata.
    * @todo Add other types of calldata.
    */
-  public async generateCalldata(proof: ProofStruct): Promise<Calldata> {
-    const calldata = await snarkjs.groth16.exportSolidityCallData(proof.proof, proof.publicSignals);
-
-    return JSON.parse(`[${calldata}]`) as Calldata;
+  public async generateCalldata(proof: ProofStructByProtocol<Type>): Promise<CalldataByProtocol<Type>> {
+    return await this._implementer.generateCalldata(proof);
   }
 
   /**
@@ -139,16 +107,25 @@ export class CircuitZKit {
    * @returns {string} The verifier name.
    */
   public getVerifierName(): string {
-    return `${this._config.circuitName}Verifier`;
+    return this._implementer.getVerifierName(this._config.circuitName);
+  }
+
+  /**
+   * Returns the type of the proving protocol
+   *
+   * @returns {ProvingSystemType} The protocol proving system type.
+   */
+  public getProvingSystemType(): ProvingSystemType {
+    return this._implementer.getProvingSystemType();
   }
 
   /**
-   * Returns the proving system of verifier template that was stored in the config
+   * Returns the Solidity verifier template.
    *
-   * @returns {VerifierProvingSystem} The verifier proving system.
+   * @returns {string} The Solidity verifier template.
    */
-  public getProvingSystem(): VerifierProvingSystem {
-    return this._config.provingSystem ?? "groth16";
+  public getVerifierTemplate(languageExtension: VerifierLanguageType): string {
+    return this._implementer.getTemplate(languageExtension);
   }
 
   /**
@@ -184,10 +161,10 @@ export class CircuitZKit {
         fileName = `${circuitName}.r1cs`;
         break;
       case "zkey":
-        fileName = `${circuitName}.zkey`;
+        fileName = `${this._implementer.getZKeyFileName(circuitName)}`;
         break;
       case "vkey":
-        fileName = `${circuitName}.vkey.json`;
+        fileName = `${this._implementer.getVKeyFileName(circuitName)}`;
         break;
       case "sym":
         fileName = `${circuitName}.sym`;

package/src/core/protocols/AbstractImplementer.ts

@@ -0,0 +1,67 @@
+import fs from "fs";
+import ejs from "ejs";
+import path from "path";
+
+import { Signals } from "../../types/proof-utils";
+import {
+  IProtocolImplementer,
+  ProvingSystemType,
+  ProofStructByProtocol,
+  CalldataByProtocol,
+} from "../../types/protocols";
+import { VerifierLanguageType } from "../../types/circuit-zkit";
+
+export abstract class AbstractProtocolImplementer<T extends ProvingSystemType> implements IProtocolImplementer<T> {
+  public async createVerifier(
+    circuitName: string,
+    vKeyFilePath: string,
+    verifierFilePath: string,
+    languageExtension: VerifierLanguageType,
+  ): Promise<void> {
+    const verifierTemplate: string = this.getTemplate(languageExtension);
+
+    if (!fs.existsSync(path.dirname(verifierFilePath))) {
+      fs.mkdirSync(path.dirname(verifierFilePath), { recursive: true });
+    }
+
+    const templateParams = JSON.parse(fs.readFileSync(vKeyFilePath, "utf-8"));
+    templateParams["verifier_id"] = this.getVerifierName(circuitName);
+
+    const verifierCode = ejs.render(verifierTemplate, templateParams);
+
+    fs.writeFileSync(verifierFilePath, verifierCode, "utf-8");
+  }
+
+  public abstract generateProof(
+    inputs: Signals,
+    zKeyFilePath: string,
+    wasmFilePath: string,
+  ): Promise<ProofStructByProtocol<T>>;
+
+  public abstract verifyProof(proof: ProofStructByProtocol<T>, vKeyFilePath: string): Promise<boolean>;
+
+  public abstract generateCalldata(proof: ProofStructByProtocol<T>): Promise<CalldataByProtocol<T>>;
+
+  public abstract getProvingSystemType(): ProvingSystemType;
+
+  public getTemplate(languageExtension: VerifierLanguageType): string {
+    return fs.readFileSync(
+      path.join(__dirname, "..", "templates", `verifier_${this.getProvingSystemType()}.${languageExtension}.ejs`),
+      "utf8",
+    );
+  }
+
+  public getVerifierName(circuitName: string): string {
+    const protocolType: ProvingSystemType = this.getProvingSystemType();
+
+    return `${circuitName}${protocolType.charAt(0).toUpperCase() + protocolType.slice(1)}Verifier`;
+  }
+
+  public getZKeyFileName(circuitName: string): string {
+    return `${circuitName}.${this.getProvingSystemType()}.zkey`;
+  }
+
+  public getVKeyFileName(circuitName: string): string {
+    return `${circuitName}.${this.getProvingSystemType()}.vkey.json`;
+  }
+}

package/src/core/protocols/Groth16Implementer.ts

@@ -0,0 +1,29 @@
+import fs from "fs";
+import * as snarkjs from "snarkjs";
+
+import { AbstractProtocolImplementer } from "./AbstractImplementer";
+
+import { Signals } from "../../types/proof-utils";
+import { Groth16ProofStruct, ProvingSystemType, Groth16Calldata } from "../../types/protocols";
+
+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;
+  }
+
+  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);
+  }
+
+  public async generateCalldata(proof: Groth16ProofStruct): Promise<Groth16Calldata> {
+    const calldata = await snarkjs.groth16.exportSolidityCallData(proof.proof, proof.publicSignals);
+
+    return JSON.parse(`[${calldata}]`) as Groth16Calldata;
+  }
+
+  public getProvingSystemType(): ProvingSystemType {
+    return "groth16";
+  }
+}

package/src/core/protocols/PlonkImplementer.ts

@@ -0,0 +1,32 @@
+import fs from "fs";
+import * as snarkjs from "snarkjs";
+
+import { AbstractProtocolImplementer } from "./AbstractImplementer";
+
+import { Signals } from "../../types/proof-utils";
+import { PlonkCalldata, PlonkProofStruct, ProvingSystemType } from "../../types/protocols";
+
+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;
+  }
+
+  public async verifyProof(proof: PlonkProofStruct, vKeyFilePath: string): Promise<boolean> {
+    const verifier = JSON.parse(fs.readFileSync(vKeyFilePath).toString());
+
+    return await snarkjs.plonk.verify(verifier, proof.publicSignals, proof.proof);
+  }
+
+  public async generateCalldata(proof: PlonkProofStruct): Promise<PlonkCalldata> {
+    const calldata = await snarkjs.plonk.exportSolidityCallData(proof.proof, proof.publicSignals);
+    const proofArrEndIndex: number = calldata.indexOf("]") + 1;
+
+    return JSON.parse(
+      `[${calldata.slice(0, proofArrEndIndex)},${calldata.slice(proofArrEndIndex, calldata.length)}]`,
+    ) as PlonkCalldata;
+  }
+
+  public getProvingSystemType(): ProvingSystemType {
+    return "plonk";
+  }
+}

package/src/core/protocols/index.ts

@@ -0,0 +1,3 @@
+export { AbstractProtocolImplementer } from "./AbstractImplementer";
+export { Groth16Implementer } from "./Groth16Implementer";
+export { PlonkImplementer } from "./PlonkImplementer";

package/src/core/templates/verifier_groth16.vy.ejs

@@ -22,7 +22,7 @@ DELTA_Y1: constant(uint256) = <%=vk_delta_2[1][1]%>
 DELTA_Y2: constant(uint256) = <%=vk_delta_2[1][0] -%>
 
 
-IC: constant(uint256[<%=IC.length%>][2]) = [
+IC: constant(uint256[2][<%=IC.length%>]) = [
 <% IC.forEach(function(innerArray, index) { %>  [
     <%= innerArray[0] %>,
     <%= innerArray[1] %>
@@ -36,7 +36,7 @@ EC_PAIRING_PRECOMPILED_ADDRESS: constant(address) = 0x00000000000000000000000000
 
 @view
 @external
-def verifyProof(pointA: uint256[2], pointB: uint256[2][2], pointC: uint256[2], publicSignals: uint256[<%=IC.length-1%>]) -> bool:
+def verifyProof(pointA: uint256[2], pointB: uint256[2][2], pointC: uint256[2], publicSignals: uint256[<%=IC.length - 1%>]) -> bool:
     # @dev check that all public signals are in F
     for signal: uint256 in publicSignals:
         if signal >= BASE_FIELD_SIZE:
@@ -84,7 +84,7 @@ def _g1MulAdd(pR: uint256[2], pP: uint256[2], s: uint256) -> (bool, uint256[2]):
 
 @view
 @internal
-def _checkPairing(pA: uint256[2], pB: uint256[2][2], pC: uint256[2], pubSignals: uint256[<%=IC.length-1%>]) -> bool:
+def _checkPairing(pA: uint256[2], pB: uint256[2][2], pC: uint256[2], pubSignals: uint256[<%=IC.length - 1%>]) -> bool:
     success: bool = True
     mulAddResult: uint256[2] = IC[0]