Added some resolvers

Author: KyrylR

src/types/common.ts

@@ -1,3 +1,5 @@
 export type CircomValueType = bigint | CircomValueType[];
 
 export type VariableContext = Record<string, CircomValueType>;
+
+export type VariableContextWithNull = Record<string, CircomValueType | null>;

src/utils/common.ts

@@ -1,4 +1,5 @@
 import { SimpleIdentifierListContext } from "../generated";
+import { VariableContext, VariableContextWithNull } from "../types";
 
 export function parseSimpleIdentifierList(
   ctx: SimpleIdentifierListContext,
@@ -15,3 +16,70 @@ export function parseSimpleIdentifierList(
 
   return result;
 }
+
+export function bindVariableContext(
+  variableName: string,
+  dimensions: number[],
+  values: any[],
+): VariableContextWithNull {
+  const context: VariableContextWithNull = {};
+
+  const resolved = resolveDimensions(variableName, dimensions);
+  for (const variable of resolved) {
+    try {
+      context[variable] = parseVariable(
+        values,
+        variable.replace(variableName, ""),
+      );
+    } catch {
+      context[variable] = null;
+    }
+  }
+
+  return context;
+}
+
+// reference MUST be similar to [0][1]
+function parseVariable(value: any, reference: string): bigint {
+  const parts = reference
+    .split("[")
+    .map((part) => part.replace("]", ""))
+    .filter((part) => part !== "")
+    .map((part) => parseInt(part));
+
+  return getReferenceValueInternal(value, parts);
+}
+
+function getReferenceValueInternal(value: any, reference: number[]): bigint {
+  if (reference.length === 0) {
+    return value;
+  }
+
+  return getReferenceValueInternal(value[reference[0]], reference.slice(1));
+}
+
+export function resolveDimensions(
+  variableName: string,
+  dimensions: number[],
+): string[] {
+  return internalResolveDimensions([variableName], dimensions, 0);
+}
+
+function internalResolveDimensions(
+  variables: string[],
+  dimensions: number[],
+  layer: number,
+): string[] {
+  if (layer >= dimensions.length) {
+    return variables;
+  }
+
+  const result: string[] = [];
+  for (let i = 0; i < dimensions[layer]; i++) {
+    for (const variable of variables) {
+      result.push(`${variable}[${i}]`);
+    }
+  }
+
+  return internalResolveDimensions(result, dimensions, layer + 1);
+}

test/circom-template-inputs-visitor.test.ts

@@ -1,19 +1,19 @@
 import { expect } from "chai";
 import { getCircomParser, VariableContext } from "../src";
 
-import { Templates } from "./mocks/types";
+import { CircomFileData, Templates } from "./mocks/types";
 import { CircomFilesVisitor } from "./mocks/CircomFilesVisitor";
 import { CircomTemplateInputsVisitor } from "./mocks/CircomTemplateInputsVisitor";
 
 describe("Circom Template Inputs Visitor", () => {
-  function getData(fileName: string): Templates {
+  function getData(fileName: string): CircomFileData {
     const visitor = new CircomFilesVisitor(fileName);
 
     const parser = getCircomParser(`test/data/${fileName}`);
 
     visitor.visit(parser.circuit());
 
-    return visitor.fileData.templates;
+    return visitor.fileData;
   }
 
   it("should analyse the curve.circom circuit", () => {
@@ -34,7 +34,7 @@ describe("Circom Template Inputs Visitor", () => {
 
     const visitor = new CircomTemplateInputsVisitor(
       "curve.circom",
-      data["RegisterIdentityBuilder"].context,
+      data.templates["RegisterIdentityBuilder"].context,
       mainComponentData,
     );
 
@@ -100,7 +100,7 @@ describe("Circom Template Inputs Visitor", () => {
 
     const visitor = new CircomTemplateInputsVisitor(
       "MainComponent.circom",
-      data["C"].context,
+      data.templates["C"].context,
       mainComponentData,
     );
 
@@ -117,4 +117,18 @@ describe("Circom Template Inputs Visitor", () => {
     expect(visitor.templateInputs.out.type).to.equal("output");
     expect(visitor.templateInputs.out.dimension).to.deep.equal([]);
   });
+
+  it.only("should analyse the ComplexMainComponent.circom circuit", () => {
+    const data = getData("ComplexMainComponent.circom");
+
+    // const visitor = new CircomTemplateInputsVisitor(
+    //   "MainComponent.circom",
+    //   data.,
+    //   {},
+    // );
+    //
+    // visitor.startParse();
+    //
+    // console.log(visitor.errors);
+  });
 });

test/data/ComplexMainComponent.circom

@@ -0,0 +1,10 @@
+pragma circom 2.1.6;
+
+template C(p1, p2){
+   signal input in1;
+   signal input in2[3][p1[1][0][0][0][0][0][0]];
+
+   signal output out <== in1 * in2[0][0] * p2[0][1][0];
+}
+
+component main {public [in1]} = C([[[[[[[10]]]]]], [[[[[[20]]]]]]], [[[30], [40]]]);

test/file-visitor.test.ts

@@ -173,4 +173,17 @@ describe("Circom File Visitor", () => {
     expect(templateA.parallel).to.equal(true);
     expect(templateA.parameters).to.deep.equal(["a1"]);
   });
+
+  it("should analyse the ComplexMainComponent.circom circuit", () => {
+    const [errors, fileData] = getData("ComplexMainComponent.circom");
+
+    expect(errors.length).to.equal(0);
+    expect(fileData.mainComponentInfo.parameters[0]).to.deep.equal([
+      [[[[[[10n]]]]]],
+      [[[[[[20n]]]]]],
+    ]);
+    expect(fileData.mainComponentInfo.parameters[1]).to.deep.equal([
+      [[30n], [40n]],
+    ]);
+  });
 });

test/utils.ts

@@ -0,0 +1,10 @@
+import { bindVariableContext, resolveDimensions } from "../src";
+
+describe("utils", () => {
+  describe("resolve dimensions", () => {
+    it.only("should resolve the case: [1]", () => {
+      console.log(bindVariableContext("a", [1, 2], [[3, 5]]));
+      console.log(bindVariableContext("a", [1, 2], []));
+    });
+  });
+});