Remove zkProgrammable (rebased) WIP

packages/api/package.json

@@ -8,7 +8,7 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
     "lint": "eslint ./src ./test",
-    "test:file": "node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads ../../node_modules/jest/bin/jest.js",
+    "test:file": "node --experimental-vm-modules  ../../node_modules/jest/bin/jest.js",
     "test": "npm run test:file -- ./test/**",
     "test:watch": "npm run test:file -- ./test/** --watch"
   },
@@ -34,7 +34,7 @@
     "@proto-kit/module": "*",
     "@proto-kit/protocol": "*",
     "@proto-kit/sequencer": "*",
-    "o1js": "^1.6.0",
+    "o1js": "^2.0.0",
     "tsyringe": "^4.7.0"
   },
   "devDependencies": {

packages/common/package.json

@@ -8,7 +8,7 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
     "lint": "eslint ./src ./test",
-    "test:file": "node --experimental-vm-modules --experimental-wasm-modules --experimental-wasm-threads ../../node_modules/jest/bin/jest.js",
+    "test:file": "node --experimental-vm-modules  ../../node_modules/jest/bin/jest.js",
     "test": "npm run test:file -- ./test/**",
     "test:watch": "npm run test:file -- ./test/** --watch"
   },
@@ -23,7 +23,7 @@
     "typescript-memoize": "^1.1.1"
   },
   "peerDependencies": {
-    "o1js": "^1.6.0",
+    "o1js": "^2.0.0",
     "tsyringe": "^4.7.0"
   },
   "devDependencies": {

packages/common/src/compiling/AtomicCompileHelper.ts

@@ -2,7 +2,7 @@ import {
   AreProofsEnabled,
   CompileArtifact,
   MOCK_VERIFICATION_KEY,
-} from "../zkProgrammable/ZkProgrammable";
+} from "../zkProgrammable/Helper";
 import { isSubtypeOfName } from "../utils";
 import { TypedClass } from "../types";
 import { log } from "../log";

packages/common/src/compiling/CompileRegistry.ts

@@ -1,9 +1,6 @@
 import { inject, injectable, singleton } from "tsyringe";
 
-import {
-  AreProofsEnabled,
-  CompileArtifact,
-} from "../zkProgrammable/ZkProgrammable";
+import { AreProofsEnabled, CompileArtifact } from "../zkProgrammable/Helper";
 
 import {
   ArtifactRecord,

packages/common/src/index.ts

@@ -3,9 +3,9 @@ export * from "./config/ConfigurableModule";
 export * from "./config/ChildContainerProvider";
 export * from "./config/ChildContainerCreatable";
 export * from "./types";
-export * from "./zkProgrammable/ZkProgrammable";
+export * from "./zkProgrammable/WithZkProgram";
+export * from "./zkProgrammable/Helper";
 export * from "./zkProgrammable/ProvableMethodExecutionContext";
-export * from "./zkProgrammable/provableMethod";
 export * from "./utils";
 export * from "./dependencyFactory/DependencyFactory";
 export * from "./dependencyFactory/injectOptional";

packages/common/src/zkProgrammable/Helper.ts

@@ -0,0 +1,23 @@
+import { Field } from "o1js";
+
+export interface AreProofsEnabled {
+  areProofsEnabled: boolean;
+  setProofsEnabled: (areProofsEnabled: boolean) => void;
+}
+export interface CompileArtifact {
+  verificationKey: {
+    data: string;
+    hash: Field;
+  };
+}
+
+export interface Compile {
+  (): Promise<CompileArtifact>;
+}
+
+export const MOCK_PROOF = "mock-proof";
+
+export const MOCK_VERIFICATION_KEY = {
+  data: "mock-verification-key",
+  hash: Field(0),
+};

packages/common/src/zkProgrammable/ProvableMethodExecutionContext.ts

@@ -2,7 +2,7 @@ import type { Proof } from "o1js";
 import { singleton } from "tsyringe";
 import uniqueId from "lodash/uniqueId";
 
-import type { ArgumentTypes } from "./provableMethod";
+import type { ArgumentTypes } from "./WithZkProgram";
 
 const errors = {
   moduleOrMethodNameNotSet: () => new Error("Module or method name not set"),
@@ -20,7 +20,10 @@ export class ProvableMethodExecutionResult {
 
   public args?: ArgumentTypes;
 
-  public prover?: () => Promise<Proof<unknown, unknown>>;
+  public prover?: () => Promise<{
+    proof: Proof<unknown, unknown>;
+    auxiliaryOutput: undefined;
+  }>;
 
   public async prove<
     ProofType extends Proof<unknown, unknown>,
@@ -35,7 +38,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 +61,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/zkProgrammable/WithZkProgram.ts

@@ -0,0 +1,78 @@
+import {
+  DynamicProof,
+  FlexibleProvablePure,
+  Proof,
+  Provable,
+  ZkProgram,
+} from "o1js";
+
+import { CompileRegistry } from "../compiling/CompileRegistry";
+
+import { Compile, CompileArtifact } from "./Helper";
+
+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 Verify<PublicInput, PublicOutput> {
+  (proof: Proof<PublicInput, PublicOutput>): Promise<boolean>;
+}
+
+export interface PlainZkProgram<PublicInput = undefined, PublicOutput = void> {
+  name: string;
+  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;
+  setProofsEnabled(proofsEnabled: boolean): void;
+}
+
+export interface ZkProgramFactory<PublicInput, PublicOutput> {
+  zkProgramFactory(): PlainZkProgram<PublicInput, PublicOutput>[];
+  compile(registry: CompileRegistry): Promise<Record<string, CompileArtifact>>;
+  // appChain: AreProofsEnabled | undefined;
+}
+
+export interface WithZkProgram<PublicInput = undefined, PublicOutput = void> {
+  readonly zkProgramFactory: ZkProgramFactory<PublicInput, PublicOutput>;
+
+  readonly zkProgram: PlainZkProgram<PublicInput, PublicOutput>[];
+}
+
+export function toProver(
+  methodName: string,
+  areProofsEnabled: boolean,
+  ...args: ArgumentTypes
+) {
+  return async function prover(this: ZkProgramFactory<any, any>) {
+    const zkProgram = this.zkProgramFactory().find((prog) =>
+      Object.keys(prog.methods).includes(methodName)
+    );
+
+    if (zkProgram === undefined) {
+      throw new Error("Correct ZkProgram not found");
+    }
+
+    const programProvableMethod = zkProgram.methods[methodName];
+    return await Reflect.apply(programProvableMethod, this, args);
+  };
+}