feature/remove-zkProgrammable

packages/api/package.json

@@ -34,7 +34,7 @@
     "@proto-kit/module": "*",
     "@proto-kit/protocol": "*",
     "@proto-kit/sequencer": "*",
-    "o1js": "^1.1.0",
+    "o1js": "^2.0.0",
     "tsyringe": "^4.7.0"
   },
   "devDependencies": {

packages/common/package.json

@@ -23,7 +23,7 @@
     "typescript-memoize": "^1.1.1"
   },
   "peerDependencies": {
-    "o1js": "^1.1.0",
+    "o1js": "^2.0.0",
     "tsyringe": "^4.7.0"
   },
   "devDependencies": {

packages/common/src/index.ts

@@ -3,9 +3,6 @@ export * from "./config/ConfigurableModule";
 export * from "./config/ChildContainerProvider";
 export * from "./config/ChildContainerCreatable";
 export * from "./types";
-export * from "./zkProgrammable/ZkProgrammable";
-export * from "./zkProgrammable/ProvableMethodExecutionContext";
-export * from "./zkProgrammable/provableMethod";
 export * from "./utils";
 export * from "./dependencyFactory/DependencyFactory";
 export * from "./dependencyFactory/injectOptional";
@@ -17,3 +14,5 @@ export * from "./trees/InMemoryMerkleTreeStorage";
 export * from "./trees/RollupMerkleTree";
 export * from "./events/EventEmitterProxy";
 export * from "./trees/MockAsyncMerkleStore";
+export * from "./zkProgram/ProvableMethodExecutionContext";
+export * from "./zkProgram/WithZkProgram";

packages/common/src/zkProgrammable/ProvableMethodExecutionContext.ts → packages/common/src/zkProgram/ProvableMethodExecutionContext.ts

@@ -1,10 +1,13 @@
-import type { Proof } from "o1js";
+import { Proof } from "o1js";
 import { singleton } from "tsyringe";
 import uniqueId from "lodash/uniqueId";
 
-import type { ArgumentTypes } from "./provableMethod";
+import { ArgumentTypes } from "./WithZkProgram";
 
 const errors = {
+  appChainNotSet: (name: string) =>
+    new Error(`Appchain was not injected for: ${name}`),
+
   moduleOrMethodNameNotSet: () => new Error("Module or method name not set"),
 
   proverNotSet: (moduleName: string, methodName: string) =>
@@ -20,7 +23,10 @@ export class ProvableMethodExecutionResult {
 
   public args?: ArgumentTypes;
 
-  public prover?: () => Promise<Proof<unknown, unknown>>;
+  public prover?: () => Promise<{
+    proof: Proof<any, any>;
+    auxiliaryOutput: undefined;
+  }>;
 
   public async prove<
     ProofType extends Proof<unknown, unknown>,
@@ -35,7 +41,7 @@ export class ProvableMethodExecutionResult {
 
     // turn the prover result into the desired proof type
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (await this.prover()) as ProofType;
+    return (await this.prover()).proof as ProofType;
   }
 }
 
@@ -58,10 +64,15 @@ export class ProvableMethodExecutionContext {
    * Adds a method prover to the current execution context,
    * which can be collected and ran asynchronously at a later point in time.
    *
-   * @param prove - Prover function to be ran later,
    * when the method execution needs to be proven
+   * @param prover
    */
-  public setProver(prover: () => Promise<Proof<unknown, unknown>>) {
+  public setProver(
+    prover: () => Promise<{
+      proof: Proof<any, any>;
+      auxiliaryOutput: undefined;
+    }>
+  ) {
     this.result.prover = prover;
   }
 

packages/common/src/zkProgram/WithZkProgram.ts

@@ -0,0 +1,95 @@
+import {
+  DynamicProof,
+  Field,
+  FlexibleProvablePure,
+  Proof,
+  Provable,
+  ZkProgram,
+} from "o1js";
+
+export type O1JSPrimitive = object | string | boolean | number;
+export type ArgumentTypes = (
+  | O1JSPrimitive
+  | Proof<unknown, unknown>
+  | DynamicProof<unknown, unknown>
+)[];
+export type DecoratedMethod = (...args: ArgumentTypes) => Promise<unknown>;
+
+export interface CompileArtifact {
+  verificationKey: {
+    data: string;
+    hash: Field;
+  };
+}
+
+export interface AreProofsEnabled {
+  areProofsEnabled: boolean;
+  setProofsEnabled: (areProofsEnabled: boolean) => void;
+}
+
+export interface Verify<PublicInput, PublicOutput> {
+  (proof: Proof<PublicInput, PublicOutput>): Promise<boolean>;
+}
+
+export interface Compile {
+  (): Promise<CompileArtifact>;
+}
+
+export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
+  compile: Compile;
+  verify: Verify<PublicInput, PublicOutput>;
+  Proof: ReturnType<
+    typeof ZkProgram.Proof<
+      FlexibleProvablePure<PublicInput>,
+      FlexibleProvablePure<PublicOutput>
+    >
+  >;
+  methods: Record<
+    string,
+    (...args: any) => Promise<{
+      proof: Proof<PublicInput, PublicOutput>;
+      auxiliaryOutput: undefined;
+    }>
+  >;
+  analyzeMethods: () => Promise<
+    Record<string, Awaited<ReturnType<typeof Provable.constraintSystem>>>
+  >;
+  proofsEnabled: boolean;
+}
+
+export interface ZkProgramFactory<PublicInput, PublicOutput> {
+  zkProgramFactory(): PlainZkProgram<PublicInput, PublicOutput>[];
+}
+
+export interface WithZkProgram<PublicInput = undefined, PublicOutput = void> {
+  readonly zkProgramFactory: ZkProgramFactory<PublicInput, PublicOutput>;
+
+  readonly zkProgram: PlainZkProgram<PublicInput, PublicOutput>[];
+}
+
+export const MOCK_PROOF = "mock-proof";
+
+export const MOCK_VERIFICATION_KEY = {
+  data: "mock-verification-key",
+  hash: Field(0),
+};
+
+export function toProver(
+  methodName: string,
+  simulatedMethod: DecoratedMethod,
+  isFirstParameterPublicInput: boolean,
+  areProofsEnabled: boolean,
+  ...args: ArgumentTypes
+) {
+  return async function prover(this: ZkProgramFactory<any, any>) {
+    for (const prog of this.zkProgramFactory()) {
+      if (Object.keys(prog.methods).includes(methodName)) {
+        prog.proofsEnabled = areProofsEnabled;
+        const programProvableMethod = prog.methods[methodName];
+        // eslint-disable-next-line no-await-in-loop
+        return await Reflect.apply(programProvableMethod, this, args);
+      }
+    }
+    throw Error("No zkProgram found with given method.");
+  };
+}