@proto-kit/common 0.1.1-develop.1661 → 0.1.1-develop.1688

package/package.json

@@ -3,7 +3,7 @@
   "license": "MIT",
   "private": false,
   "type": "module",
-  "version": "0.1.1-develop.1661+ec6f5592",
+  "version": "0.1.1-develop.1688+a8257e42",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
@@ -24,12 +24,12 @@
     "typescript-memoize": "^1.1.1"
   },
   "peerDependencies": {
-    "o1js": "^1.6.0",
+    "o1js": "^2.10.0",
     "tsyringe": "^4.10.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
     "@types/lodash": "^4.14.194"
   },
-  "gitHead": "ec6f55921b35d7faaab233f1ca9cf591c6263d01"
+  "gitHead": "a8257e428f8cda2b7252ead17e29482d2fdb0575"
 }

package/src/zkProgrammable/ZkProgrammable.ts

@@ -33,7 +33,10 @@ export interface Compile {
   (): Promise<CompileArtifact>;
 }
 
-export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
+export interface PlainZkProgram<
+  PublicInput = undefined,
+  PublicOutput = undefined,
+> {
   name: string;
   compile: Compile;
   verify: Verify<PublicInput, PublicOutput>;
@@ -45,11 +48,17 @@ export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
   >;
   methods: Record<
     string,
-    | ((...args: any) => Promise<Proof<PublicInput, PublicOutput>>)
+    | ((...args: any) => Promise<{
+        proof: Proof<PublicInput, PublicOutput>;
+        auxiliaryOutput: any;
+      }>)
     | ((
         publicInput: PublicInput,
         ...args: any
-      ) => Promise<Proof<PublicInput, PublicOutput>>)
+      ) => Promise<{
+        proof: Proof<PublicInput, PublicOutput>;
+        auxiliaryOutput: any;
+      }>)
   >;
   analyzeMethods: () => Promise<
     Record<string, Awaited<ReturnType<typeof Provable.constraintSystem>>>

package/src/zkProgrammable/provableMethod.ts

@@ -38,7 +38,9 @@ export function toProver(
 
     if (areProofsEnabled) {
       const programProvableMethod = zkProgram.methods[methodName];
-      return await Reflect.apply(programProvableMethod, this, args);
+      const result = await Reflect.apply(programProvableMethod, this, args);
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return result.proof as Proof<any, any>;
     }
 
     // create a mock proof by simulating method> execution in JS
@@ -49,8 +51,18 @@ export function toProver(
 
       // TODO: provide undefined if public input is not used
       publicInput: isFirstParameterPublicInput ? args[0] : undefined,
-      publicOutput,
-
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      publicOutput: (() => {
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!publicOutput || typeof publicOutput !== "object") {
+          return undefined;
+        }
+        if ("publicOutput" in publicOutput) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return (publicOutput as any).publicOutput;
+        }
+        return publicOutput;
+      })(),
       /**
        * We set this to the max possible number, to avoid having
        * to manually count in-circuit proof verifications

package/test/zkProgrammable/ZkProgrammable.test.ts

@@ -42,18 +42,22 @@ class TestProgrammable extends ZkProgrammable<
   @provableMethod()
   public async foo(publicInput: TestPublicInput, bar: Balance) {
     // expose the private input as public output again for testing purposes
-    return new TestPublicOutput({
-      bar,
-    });
+    return {
+      publicOutput: new TestPublicOutput({
+        bar,
+      }),
+    };
   }
 
   @provableMethod()
   public async fail(publicInput: TestPublicInput) {
     publicInput.foo.assertEquals(1, failErrorMessage);
 
-    return new TestPublicOutput({
-      bar: Field(0),
-    });
+    return {
+      publicOutput: new TestPublicOutput({
+        bar: Field(0),
+      }),
+    };
   }
 
   public zkProgramFactory() {
@@ -272,7 +276,7 @@ describe("zkProgrammable", () => {
             // proof bar
             const otherTestProof = await executionContext
               .current()
-              .result.prove<Proof<undefined, void>>();
+              .result.prove<Proof<undefined, undefined>>();
             const otherTestProofVerified =
               await otherTestProgrammable.zkProgram[0].verify(otherTestProof);