Improve UX. Restructure type generation function.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solarity/zktype",
-  "version": "0.4.0-rc.0",
+  "version": "0.4.0-rc.1",
   "description": "Unleash TypeScript bindings for Circom circuits",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/core/BaseTSGenerator.ts

@@ -70,11 +70,12 @@ export default class BaseTSGenerator {
    * Extracts the type name from the circuit artifact.
    *
    * @param {CircuitArtifact} circuitArtifact - The circuit artifact from which the type name is extracted.
+   * @param protocolType - The protocol type to be added to the type name.
    * @param {string} [prefix=""] - The prefix to be added to the type name.
    * @returns {string} The extracted type name.
    */
-  protected _getTypeName(circuitArtifact: CircuitArtifact, prefix: string = ""): string {
-    return `${prefix}${circuitArtifact.circuitTemplateName.replace(path.extname(circuitArtifact.circuitTemplateName), "")}`;
+  protected _getTypeName(circuitArtifact: CircuitArtifact, protocolType: string, prefix: string = ""): string {
+    return `${prefix}${circuitArtifact.circuitTemplateName.replace(path.extname(circuitArtifact.circuitTemplateName), "")}${protocolType}`;
   }
 
   /**

src/core/CircuitTypesGenerator.ts

@@ -7,7 +7,7 @@ import ZkitTSGenerator from "./ZkitTSGenerator";
 import { normalizeName } from "../utils";
 
 import { Formats } from "../constants";
-import { CircuitArtifact, ArtifactWithPath, GeneratedCircuitWrapperResult } from "../types";
+import { CircuitArtifact, GeneratedCircuitWrapperResult, CircuitSet } from "../types";
 
 /**
  * `CircuitTypesGenerator` is need for generating TypeScript bindings based on circuit artifacts.
@@ -65,7 +65,7 @@ export class CircuitTypesGenerator extends ZkitTSGenerator {
     fs.mkdirSync(this.getOutputTypesDir(), { recursive: true });
 
     const isNameExist: Map<string, boolean> = new Map();
-    const typePathsToResolve: ArtifactWithPath[] = [];
+    const circuitSet: CircuitSet = {};
 
     for (let i = 0; i < circuitArtifacts.length; i++) {
       const circuitName = circuitArtifacts[i].circuitTemplateName;
@@ -102,15 +102,21 @@ export class CircuitTypesGenerator extends ZkitTSGenerator {
 
         this._saveFileContent(circuitTypePath, preparedNode.content);
 
-        typePathsToResolve.push({
+        if (!circuitSet[circuitName]) {
+          circuitSet[circuitName] = [];
+        }
+
+        circuitSet[circuitName].push({
           circuitArtifact: circuitArtifacts[i],
           pathToGeneratedFile: path.join(this.getOutputTypesDir(), circuitTypePath),
-          protocol: circuitArtifacts[i].baseCircuitInfo.protocol.length > 1 ? preparedNode.prefix : undefined,
+          protocol: preparedNode.protocol,
         });
       }
     }
 
-    await this._resolveTypePaths(typePathsToResolve);
+    await this._resolveTypePaths(circuitSet);
+    await this._saveMainIndexFile(circuitSet);
+    await this._saveHardhatZkitTypeExtensionFile(circuitSet);
 
     // copy utils to types output dir
     const utilsDirPath = this.getOutputTypesDir();
@@ -119,81 +125,87 @@ export class CircuitTypesGenerator extends ZkitTSGenerator {
   }
 
   /**
-   * Generates the index files in the `TYPES_DIR` directory and its subdirectories.
-   *
-   * @param {ArtifactWithPath[]} typePaths - The paths to the generated files and the corresponding circuit artifacts.
+   * Generates the index files in the subdirectories of the `TYPES_DIR` directory.
    */
-  private async _resolveTypePaths(typePaths: ArtifactWithPath[]): Promise<void> {
+  private async _resolveTypePaths(circuitSet: CircuitSet): Promise<void> {
     const rootTypesDirPath = this.getOutputTypesDir();
-    const pathToMainIndexFile = path.join(rootTypesDirPath, "index.ts");
 
     // index file path => its content
-    const indexFilesMap: Map<string, string[]> = new Map();
-    const isCircuitNameExist: Map<string, number> = new Map();
-
-    const topLevelCircuits: {
-      [circuitName: string]: ArtifactWithPath[];
-    } = {};
-
-    for (const typePath of typePaths) {
-      const levels: string[] = typePath.pathToGeneratedFile
-        .replace(this.getOutputTypesDir(), "")
-        .split(path.sep)
-        .filter((level) => level !== "");
-
-      for (let i = 0; i < levels.length; i++) {
-        const pathToIndexFile =
-          i === 0
-            ? path.join(rootTypesDirPath, "index.ts")
-            : path.join(rootTypesDirPath, levels.slice(0, i).join(path.sep), "index.ts");
-
-        const exportDeclaration =
-          path.extname(levels[i]) === ".ts"
-            ? this._getExportDeclarationForFile(levels[i])
-            : this._getExportDeclarationForDirectory(levels[i]);
-
-        if (
-          indexFilesMap.get(pathToIndexFile) === undefined ||
-          !indexFilesMap.get(pathToIndexFile)?.includes(exportDeclaration)
-        ) {
-          indexFilesMap.set(pathToIndexFile, [
-            ...(indexFilesMap.get(pathToIndexFile) === undefined ? [] : indexFilesMap.get(pathToIndexFile)!),
-            exportDeclaration,
-          ]);
+    const indexFilesMap: Map<string, Set<string>> = new Map();
+
+    for (const [, artifactWithPaths] of Object.entries(circuitSet)) {
+      for (const artifactWithPath of artifactWithPaths) {
+        const levels: string[] = artifactWithPath.pathToGeneratedFile
+          .replace(this.getOutputTypesDir(), "")
+          .split(path.sep)
+          .filter((level) => level !== "");
+
+        for (let i = 1; i < levels.length; i++) {
+          const pathToIndexFile = path.join(rootTypesDirPath, levels.slice(0, i).join(path.sep), "index.ts");
+
+          if (!indexFilesMap.has(pathToIndexFile)) {
+            indexFilesMap.set(pathToIndexFile, new Set());
+          }
+
+          const exportDeclaration =
+            path.extname(levels[i]) === ".ts"
+              ? this._getExportDeclarationForFile(levels[i])
+              : this._getExportDeclarationForDirectory(levels[i]);
+
+          if (
+            indexFilesMap.get(pathToIndexFile) === undefined ||
+            !indexFilesMap.get(pathToIndexFile)!.has(exportDeclaration)
+          ) {
+            indexFilesMap.set(pathToIndexFile, indexFilesMap.get(pathToIndexFile)!.add(exportDeclaration));
+          }
         }
       }
+    }
+
+    for (const [absolutePath, content] of indexFilesMap) {
+      this._saveFileContent(path.relative(this.getOutputTypesDir(), absolutePath), Array.from(content).join("\n"));
+    }
+  }
+
+  private async _saveMainIndexFile(circuitSet: CircuitSet): Promise<void> {
+    let mainIndexFileContent = this._getExportDeclarationForDirectory(CircuitTypesGenerator.DOMAIN_SEPARATOR) + "\n";
+
+    for (const [, artifactWithPaths] of Object.entries(circuitSet)) {
+      let isCircuitNameOverlaps = false;
+      const seenProtocols: string[] = [];
+
+      for (const artifactWithPath of artifactWithPaths) {
+        if (seenProtocols.includes(artifactWithPath.protocol)) {
+          isCircuitNameOverlaps = true;
+          break;
+        }
 
-      const circuitName = typePath.circuitArtifact.circuitTemplateName;
+        seenProtocols.push(artifactWithPath.protocol);
+      }
 
-      if (
-        isCircuitNameExist.get(circuitName) === undefined ||
-        isCircuitNameExist.get(circuitName)! < typePath.circuitArtifact.baseCircuitInfo.protocol.length
-      ) {
-        indexFilesMap.set(pathToMainIndexFile, [
-          ...(indexFilesMap.get(pathToMainIndexFile) === undefined ? [] : indexFilesMap.get(pathToMainIndexFile)!),
-          this._getExportDeclarationForFile(path.relative(this._projectRoot, levels.join(path.sep))),
-        ]);
+      if (isCircuitNameOverlaps) {
+        continue;
       }
 
-      isCircuitNameExist.set(
-        circuitName,
-        isCircuitNameExist.get(circuitName) === undefined ? 1 : isCircuitNameExist.get(circuitName)! + 1,
-      );
+      for (const artifactWithPath of artifactWithPaths) {
+        const levels: string[] = artifactWithPath.pathToGeneratedFile
+          .replace(this.getOutputTypesDir(), "")
+          .split(path.sep)
+          .filter((level) => level !== "");
 
-      topLevelCircuits[circuitName] =
-        topLevelCircuits[circuitName] === undefined ? [typePath] : [...topLevelCircuits[circuitName], typePath];
-    }
+        const exportPathToCircuitType = this._getExportDeclarationForFile(
+          path.relative(this._projectRoot, levels.join(path.sep)),
+        );
 
-    for (const [absolutePath, content] of indexFilesMap) {
-      this._saveFileContent(path.relative(this.getOutputTypesDir(), absolutePath), content.join("\n"));
+        mainIndexFileContent += exportPathToCircuitType + "\n";
+      }
     }
 
-    const pathToTypesExtensionFile = path.join(rootTypesDirPath, "hardhat.d.ts");
+    this._saveFileContent("index.ts", mainIndexFileContent);
+  }
 
-    this._saveFileContent(
-      path.relative(this.getOutputTypesDir(), pathToTypesExtensionFile),
-      await this._genHardhatZkitTypeExtension(topLevelCircuits),
-    );
+  private async _saveHardhatZkitTypeExtensionFile(circuitSet: CircuitSet): Promise<void> {
+    this._saveFileContent("hardhat.d.ts", await this._genHardhatZkitTypeExtension(circuitSet));
   }
 
   /**

src/core/ZkitTSGenerator.ts

@@ -7,25 +7,23 @@ import prettier from "prettier";
 import BaseTSGenerator from "./BaseTSGenerator";
 
 import {
-  ArtifactWithPath,
   CircuitArtifact,
   CircuitClass,
   Inputs,
   TypeExtensionTemplateParams,
-  DefaultWrapperTemplateParams,
   WrapperTemplateParams,
   SignalInfo,
   GeneratedCircuitWrapperResult,
+  CircuitSet,
+  ProtocolType,
 } from "../types";
 
 import { normalizeName } from "../utils";
 import { SignalTypeNames, SignalVisibilityNames } from "../constants";
 import { Groth16CalldataPointsType, PlonkCalldataPointsType } from "../constants/protocol";
 
 export default class ZkitTSGenerator extends BaseTSGenerator {
-  protected async _genHardhatZkitTypeExtension(circuits: {
-    [circuitName: string]: ArtifactWithPath[];
-  }): Promise<string> {
+  protected async _genHardhatZkitTypeExtension(circuits: CircuitSet): Promise<string> {
     const template = fs.readFileSync(path.join(__dirname, "templates", "type-extension.ts.ejs"), "utf8");
 
     const circuitClasses: CircuitClass[] = [];
@@ -90,11 +88,9 @@ export default class ZkitTSGenerator extends BaseTSGenerator {
     circuitArtifact: CircuitArtifact,
     pathToGeneratedFile: string,
   ): Promise<GeneratedCircuitWrapperResult[]> {
-    this._validateCircuitArtifact(circuitArtifact);
-
     const result: GeneratedCircuitWrapperResult[] = [];
 
-    const unifiedProtocolType = new Set(circuitArtifact.baseCircuitInfo.protocol);
+    const unifiedProtocolType = this._getUnifiedProtocolType(circuitArtifact);
     for (const protocolType of unifiedProtocolType) {
       const content = await this._genSingleCircuitWrapperClassContent(
         circuitArtifact,
@@ -109,16 +105,6 @@ export default class ZkitTSGenerator extends BaseTSGenerator {
     return result;
   }
 
-  protected async _genDefaultCircuitWrapperClassContent(circuitArtifact: CircuitArtifact): Promise<string> {
-    const template = fs.readFileSync(path.join(__dirname, "templates", "default-circuit-wrapper.ts.ejs"), "utf8");
-
-    const templateParams: DefaultWrapperTemplateParams = {
-      circuitClassName: this._getCircuitName(circuitArtifact),
-    };
-
-    return await prettier.format(ejs.render(template, templateParams), { parser: "typescript" });
-  }
-
   private async _genSingleCircuitWrapperClassContent(
     circuitArtifact: CircuitArtifact,
     pathToGeneratedFile: string,
@@ -175,20 +161,21 @@ export default class ZkitTSGenerator extends BaseTSGenerator {
       protocolImplementerName: this._getProtocolImplementerName(protocolType),
       proofTypeInternalName: this._getProofTypeInternalName(protocolType),
       circuitClassName,
-      publicInputsTypeName: this._getTypeName(circuitArtifact, "Public"),
+      publicInputsTypeName: this._getTypeName(circuitArtifact, this._getPrefix(protocolType), "Public"),
       calldataPubSignalsType: this._getCalldataPubSignalsType(calldataPubSignalsCount),
       publicInputs,
       privateInputs,
       calldataPointsType: this._getCalldataPointsType(protocolType),
-      proofTypeName: this._getTypeName(circuitArtifact, "Proof"),
-      privateInputsTypeName: this._getTypeName(circuitArtifact, "Private"),
+      proofTypeName: this._getTypeName(circuitArtifact, this._getPrefix(protocolType), "Proof"),
+      calldataTypeName: this._getTypeName(circuitArtifact, this._getPrefix(protocolType), "Calldata"),
+      privateInputsTypeName: this._getTypeName(circuitArtifact, this._getPrefix(protocolType), "Private"),
       pathToUtils: path.relative(path.dirname(pathToGeneratedFile), pathToUtils),
     };
 
     return {
       content: await prettier.format(ejs.render(template, templateParams), { parser: "typescript" }),
       className: circuitClassName,
-      prefix: this._getPrefix(protocolType).toLowerCase(),
+      protocol: protocolType,
     };
   }
 
@@ -250,9 +237,11 @@ export default class ZkitTSGenerator extends BaseTSGenerator {
     }
   }
 
-  private _validateCircuitArtifact(circuitArtifact: CircuitArtifact): void {
+  private _getUnifiedProtocolType(circuitArtifact: CircuitArtifact): Set<ProtocolType> {
     if (!circuitArtifact.baseCircuitInfo.protocol) {
-      throw new Error(`ZKType: Protocol is missing in the circuit artifact: ${circuitArtifact.circuitTemplateName}`);
+      return new Set(["groth16"]);
     }
+
+    return new Set(circuitArtifact.baseCircuitInfo.protocol);
   }
 }

src/core/templates/circuit-wrapper.ts.ejs

@@ -29,7 +29,7 @@ export type <%= proofTypeName %> = {
   publicSignals: <%= publicInputsTypeName %>;
 }
 
-export type Calldata = [
+export type <%= calldataTypeName %> = [
     <%= calldataPointsType %>,
     <%= calldataPubSignalsType %>,
 ];
@@ -59,7 +59,7 @@ export class <%= circuitClassName %> extends CircuitZKit<"<%= protocolTypeName %
     });
   }
 
-  public async generateCalldata(proof: <%= proofTypeName %>): Promise<Calldata> {
+  public async generateCalldata(proof: <%= proofTypeName %>): Promise<<%= calldataTypeName %>> {
     return super.generateCalldata({
       proof: proof.proof,
       publicSignals: this._denormalizePublicSignals(proof.publicSignals),

src/types/circuitArtifact.ts

@@ -1,5 +1,7 @@
 export type FormatTypes = "hh-zkit-artifacts-1";
 
+export type ProtocolType = "groth16" | "plonk";
+
 export type SignalType = "Output" | "Input" | "Intermediate";
 
 export type VisibilityType = "Public" | "Private";