@proto-kit/common 0.1.1-develop.1088 → 0.1.1-develop.1313

package/src/zkProgrammable/ZkProgrammable.ts

@@ -2,12 +2,15 @@ import { ZkProgram, FlexibleProvablePure, Proof, Field, Provable } from "o1js";
 import { Memoize } from "typescript-memoize";
 
 import { log } from "../log";
+import { dummyVerificationKey } from "../dummyVerificationKey";
+import { reduceSequential } from "../utils";
+import type { CompileRegistry } from "../compiling/CompileRegistry";
 
 import { MOCK_PROOF } from "./provableMethod";
 
 const errors = {
-  appChainNotSet: (name: string) =>
-    new Error(`Appchain was not injected for: ${name}`),
+  areProofsEnabledNotSet: (name: string) =>
+    new Error(`AreProofsEnabled was not injected for: ${name}`),
 };
 
 export interface CompileArtifact {
@@ -31,6 +34,7 @@ export interface Compile {
 }
 
 export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
+  name: string;
   compile: Compile;
   verify: Verify<PublicInput, PublicOutput>;
   Proof: ReturnType<
@@ -75,10 +79,7 @@ export function verifyToMockable<PublicInput, PublicOutput>(
   };
 }
 
-export const MOCK_VERIFICATION_KEY = {
-  data: "mock-verification-key",
-  hash: Field(0),
-};
+export const MOCK_VERIFICATION_KEY = dummyVerificationKey();
 
 export function compileToMockable(
   compile: Compile,
@@ -99,28 +100,47 @@ export abstract class ZkProgrammable<
   PublicInput = undefined,
   PublicOutput = void,
 > {
-  public abstract get appChain(): AreProofsEnabled | undefined;
+  public abstract get areProofsEnabled(): AreProofsEnabled | undefined;
 
   public abstract zkProgramFactory(): PlainZkProgram<
     PublicInput,
     PublicOutput
   >[];
 
+  private zkProgramSingleton?: PlainZkProgram<PublicInput, PublicOutput>[];
+
   @Memoize()
   public get zkProgram(): PlainZkProgram<PublicInput, PublicOutput>[] {
-    const zkProgram = this.zkProgramFactory();
+    if (this.zkProgramSingleton === undefined) {
+      this.zkProgramSingleton = this.zkProgramFactory();
+    }
 
-    return zkProgram.map((bucket) => {
-      if (!this.appChain) {
-        throw errors.appChainNotSet(this.constructor.name);
+    return this.zkProgramSingleton.map((bucket) => {
+      if (!this.areProofsEnabled) {
+        throw errors.areProofsEnabledNotSet(this.constructor.name);
       }
       return {
         ...bucket,
-        verify: verifyToMockable(bucket.verify, this.appChain),
-        compile: compileToMockable(bucket.compile, this.appChain),
+        verify: verifyToMockable(bucket.verify, this.areProofsEnabled),
+        compile: compileToMockable(bucket.compile, this.areProofsEnabled),
       };
     });
   }
+
+  public async compile(registry: CompileRegistry) {
+    return await reduceSequential(
+      this.zkProgram,
+      async (acc, program) => {
+        const result = await registry.compile(program);
+        return {
+          ...acc,
+          [program.name]: result,
+        };
+      },
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      {} as Record<string, CompileArtifact>
+    );
+  }
 }
 
 export interface WithZkProgrammable<

package/src/zkProgrammable/provableMethod.ts

@@ -15,6 +15,7 @@ export type ArgumentTypes = (
 export type DecoratedMethod = (...args: ArgumentTypes) => Promise<unknown>;
 
 export const MOCK_PROOF = "mock-proof";
+// (await Proof.dummy(Field(0), Field(0), 2)).proof as string;
 
 export function toProver(
   methodName: string,
@@ -23,23 +24,23 @@ export function toProver(
   ...args: ArgumentTypes
 ) {
   return async function prover(this: ZkProgrammable<any, any>) {
-    const areProofsEnabled = this.appChain?.areProofsEnabled;
-    if (areProofsEnabled ?? false) {
-      for (const prog of this.zkProgram) {
-        if (Object.keys(prog.methods).includes(methodName)) {
-          const programProvableMethod = prog.methods[methodName];
-          // eslint-disable-next-line no-await-in-loop
-          return await Reflect.apply(programProvableMethod, this, args);
-        }
-      }
+    const { areProofsEnabled } = this.areProofsEnabled!;
+
+    const zkProgram = this.zkProgram.find((prog) =>
+      Object.keys(prog.methods).includes(methodName)
+    );
+
+    if (zkProgram === undefined) {
+      throw new Error("Correct ZkProgram not found");
+    }
+
+    if (areProofsEnabled) {
+      const programProvableMethod = zkProgram.methods[methodName];
+      return await Reflect.apply(programProvableMethod, this, args);
     }
 
-    // create a mock proof by simulating method execution in JS
+    // create a mock proof by simulating method> execution in JS
     const publicOutput = await Reflect.apply(simulatedMethod, this, args);
-    const zkProgram =
-      this.zkProgram.find((prog) => {
-        return Object.keys(prog.methods).includes(methodName);
-      }) ?? this.zkProgram[0];
 
     return new zkProgram.Proof({
       proof: MOCK_PROOF,

package/test/config/ModuleContainer.test.ts

@@ -10,7 +10,8 @@ import {
   ModulesRecord,
 } from "../../src/config/ModuleContainer";
 import { TypedClass } from "../../src/types";
-import { DependencyFactory } from "../../src";
+import { DependencyFactory, expectDefined } from "../../src";
+import { injectAlias } from "../../src/config/injectAlias";
 
 // module container will accept modules that extend this type
 class BaseTestModule<Config> extends ConfigurableModule<Config> {}
@@ -24,6 +25,7 @@ interface TestModuleConfig {
 }
 
 @injectable()
+@injectAlias(["child-alias", "multi-alias"])
 class ChildModule extends BaseTestModule<NoConfig> {
   public constructor(@inject("TestModule") public readonly testModule: any) {
     super();
@@ -34,6 +36,7 @@ class ChildModule extends BaseTestModule<NoConfig> {
   }
 }
 
+@injectAlias(["base-alias", "multi-alias"])
 class TestModule
   extends BaseTestModule<TestModuleConfig>
   implements DependencyFactory
@@ -66,7 +69,11 @@ class WrongTestModule {}
 
 class TestModuleContainer<
   Modules extends TestModulesRecord,
-> extends ModuleContainer<Modules> {}
+> extends ModuleContainer<Modules> {
+  public get dependencyContainer() {
+    return this.container;
+  }
+}
 
 describe("moduleContainer", () => {
   let container: TestModuleContainer<{
@@ -169,4 +176,40 @@ describe("moduleContainer", () => {
     expect(config.testConfigProperty2).toBe(2);
     expect(config.testConfigProperty3).toBe(undefined);
   });
+
+  it("should resolve dependencies correctly via alias", () => {
+    container.configure({
+      TestModule: {
+        testConfigProperty,
+      },
+
+      OtherTestModule: {
+        otherTestConfigProperty: testConfigProperty,
+      },
+    });
+
+    container.create(() => tsyringeContainer.createChildContainer());
+
+    // Unfortunately we still need this so that the dependencies are registered
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const m1 = container.resolve("base-alias" as any);
+    const m2 = container.resolve("TestModule");
+
+    expectDefined(m1);
+    // Check if its the same reference
+    expect(m1).toBe(m2);
+
+    const dm1 = container.resolve("child-alias" as any) as ChildModule;
+    const dm2 = container.resolve("DependencyModule1");
+
+    expect(dm1.x()).toBe("dependency factory works");
+    expect(dm1.testModule).toBeDefined();
+    expect(dm1).toBe(dm2);
+
+    const multi =
+      container.dependencyContainer.resolveAll<BaseTestModule<unknown>>(
+        "multi-alias"
+      );
+    expect(multi).toHaveLength(2);
+  });
 });

package/test/config/injectAlias.test.ts

@@ -0,0 +1,28 @@
+import "reflect-metadata";
+import { getInjectAliases, injectAlias } from "../../src/config/injectAlias";
+
+@injectAlias(["foo", "bar"])
+class TestClass {}
+
+@injectAlias(["ayy"])
+class TestClass2 extends TestClass {}
+
+describe("injectAlias metadata", () => {
+  it("set and retrieve", () => {
+    expect.assertions(2);
+
+    const aliases = getInjectAliases(TestClass);
+
+    expect(aliases).toHaveLength(2);
+    expect(aliases).toStrictEqual(["foo", "bar"]);
+  });
+
+  it("recursive", () => {
+    expect.assertions(2);
+
+    const aliases = getInjectAliases(TestClass2);
+
+    expect(aliases).toHaveLength(3);
+    expect(aliases).toStrictEqual(["ayy", "foo", "bar"]);
+  });
+});

package/test/zkProgrammable/ZkProgrammable.test.ts

@@ -6,14 +6,12 @@ import { Field, Struct, Proof, ZkProgram } from "o1js";
 import {
   MOCK_PROOF,
   provableMethod,
-} from "../../src/zkProgrammable/provableMethod";
-import {
   AreProofsEnabled,
   CompileArtifact,
   MOCK_VERIFICATION_KEY,
   ZkProgrammable,
-} from "../../src/zkProgrammable/ZkProgrammable";
-import { ProvableMethodExecutionContext } from "../../src/zkProgrammable/ProvableMethodExecutionContext";
+  ProvableMethodExecutionContext,
+} from "../../src";
 
 const appChainMock: AreProofsEnabled = {
   areProofsEnabled: false,
@@ -39,7 +37,7 @@ class TestProgrammable extends ZkProgrammable<
   TestPublicInput,
   TestPublicOutput
 > {
-  public appChain: AreProofsEnabled = appChainMock;
+  public areProofsEnabled: AreProofsEnabled = appChainMock;
 
   @provableMethod()
   public async foo(publicInput: TestPublicInput, bar: Balance) {
@@ -86,6 +84,7 @@ class TestProgrammable extends ZkProgrammable<
 
     return [
       {
+        name: program.name,
         compile: program.compile.bind(program),
         verify: program.verify.bind(program),
         analyzeMethods: program.analyzeMethods.bind(program),
@@ -97,7 +96,7 @@ class TestProgrammable extends ZkProgrammable<
 }
 
 class OtherTestProgrammable extends ZkProgrammable<undefined, void> {
-  public appChain: AreProofsEnabled = appChainMock;
+  public areProofsEnabled: AreProofsEnabled = appChainMock;
 
   public constructor(public testProgrammable: TestProgrammable) {
     super();
@@ -129,6 +128,7 @@ class OtherTestProgrammable extends ZkProgrammable<undefined, void> {
 
     return [
       {
+        name: program.name,
         compile: program.compile.bind(program),
         verify: program.verify.bind(program),
         analyzeMethods: program.analyzeMethods.bind(program),
@@ -183,7 +183,7 @@ describe("zkProgrammable", () => {
     (areProofsEnabled, { verificationKey, shouldVerifyMockProofs }) => {
       beforeAll(async () => {
         testProgrammable = new TestProgrammable();
-        testProgrammable.appChain.setProofsEnabled(areProofsEnabled);
+        testProgrammable.areProofsEnabled.setProofsEnabled(areProofsEnabled);
         zkProgramFactorySpy = jest.spyOn(testProgrammable, "zkProgramFactory");
         artifact = await testProgrammable.zkProgram[0].compile();
       }, 500_000);

package/dist/test/equalProvable.d.ts

@@ -1,20 +0,0 @@
-import { Field } from "o1js";
-export declare function equalProvable(received: Field[], expected: Field[]): {
-    message: () => string;
-    pass: boolean;
-};
-interface CustomMatchers<R = void> {
-    equalProvable(expected: Field[]): R;
-}
-declare global {
-    namespace jest {
-        interface Expect extends CustomMatchers {
-        }
-        interface Matchers<R> extends CustomMatchers<R> {
-        }
-        interface InverseAsymmetricMatchers extends CustomMatchers {
-        }
-    }
-}
-export {};
-//# sourceMappingURL=equalProvable.d.ts.map

package/dist/test/equalProvable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"equalProvable.d.ts","sourceRoot":"","sources":["../../src/test/equalProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAE7B,wBAAgB,aAAa,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE;;;EAajE;AAMD,UAAU,cAAc,CAAC,CAAC,GAAG,IAAI;IAC/B,aAAa,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;CACrC;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,IAAI,CAAC;QACb,UAAU,MAAO,SAAQ,cAAc;SAAG;QAC1C,UAAU,QAAQ,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;SAAG;QAClD,UAAU,yBAA0B,SAAQ,cAAc;SAAG;KAC9D;CACF"}

package/dist/test/equalProvable.js

@@ -1,13 +0,0 @@
-export function equalProvable(received, expected) {
-    expect(received).toHaveLength(expected.length);
-    const receivedBigInts = received.map((f) => f.toBigInt());
-    const expectedBigInts = expected.map((f) => f.toBigInt());
-    const pass = receivedBigInts.every((v, index) => v === expectedBigInts[index]);
-    return {
-        message: () => `Expected ${expectedBigInts}, received ${receivedBigInts}`,
-        pass,
-    };
-}
-expect.extend({
-    equalProvable,
-});