@proto-kit/common 0.1.1-develop.0

package/dist/zkProgrammable/ProvableMethodExecutionContext.d.ts

@@ -0,0 +1,54 @@
+import type { Proof } from "o1js";
+import type { ArgumentTypes } from "./provableMethod";
+export declare class ProvableMethodExecutionResult {
+    moduleName?: string;
+    methodName?: string;
+    args?: ArgumentTypes;
+    prover?: () => Promise<Proof<unknown, unknown>>;
+    prove<ProofType extends Proof<unknown, unknown>>(): Promise<ProofType>;
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+export declare class ProvableMethodExecutionContext {
+    id: string;
+    methods: string[];
+    result: ProvableMethodExecutionResult;
+    /**
+     * 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
+     */
+    setProver(prover: () => Promise<Proof<unknown, unknown>>): void;
+    /**
+     * Adds a method to the method execution stack, reseting the execution context
+     * in a case a new top-level (non nested) method call is made.
+     *
+     * @param methodName - Name of the method being captured in the context
+     */
+    beforeMethod(moduleName: string, methodName: string, args: ArgumentTypes): void;
+    /**
+     * Removes the latest method from the execution context stack,
+     * keeping track of the amount of 'unfinished' methods. Allowing
+     * for the context to distinguish between top-level and nested method calls.
+     */
+    afterMethod(): void;
+    get isTopLevel(): boolean;
+    get isFinished(): boolean;
+    /**
+     * @returns - Current execution context state
+     */
+    current(): {
+        isFinished: boolean;
+        result: ProvableMethodExecutionResult;
+    };
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear(): void;
+}
+//# sourceMappingURL=ProvableMethodExecutionContext.d.ts.map

package/dist/zkProgrammable/ProvableMethodExecutionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../src/zkProgrammable/ProvableMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAIlC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAWtD,qBAAa,6BAA6B;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,IAAI,CAAC,EAAE,aAAa,CAAC;IAErB,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IAE1C,KAAK,CAChB,SAAS,SAAS,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,KACtC,OAAO,CAAC,SAAS,CAAC;CAaxB;AAED;;;;GAIG;AACH,qBACa,8BAA8B;IAClC,EAAE,SAAc;IAEhB,OAAO,EAAE,MAAM,EAAE,CAAM;IAEvB,MAAM,EAAE,6BAA6B,CACN;IAGtC;;;;;;OAMG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAI/D;;;;;OAKG;IACI,YAAY,CACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,aAAa;IAYrB;;;;OAIG;IACI,WAAW;IAIlB,IAAW,UAAU,YAEpB;IAED,IAAW,UAAU,YAEpB;IAED;;OAEG;IACI,OAAO;;;;IAOd;;OAEG;IACI,KAAK;CAGb"}

package/dist/zkProgrammable/ProvableMethodExecutionContext.js

@@ -0,0 +1,97 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { singleton } from "tsyringe";
+import uniqueId from "lodash/uniqueId";
+const errors = {
+    moduleOrMethodNameNotSet: () => new Error("Module or method name not set"),
+    proverNotSet: (moduleName, methodName) => new Error(`Prover not set for '${moduleName}.${methodName}', did you forget to decorate your method?`),
+};
+export class ProvableMethodExecutionResult {
+    async prove() {
+        if (!this.prover) {
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (!this.moduleName || !this.methodName) {
+                throw errors.moduleOrMethodNameNotSet();
+            }
+            throw errors.proverNotSet(this.moduleName, this.methodName);
+        }
+        // turn the prover result into the desired proof type
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return (await this.prover());
+    }
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+export let ProvableMethodExecutionContext = class ProvableMethodExecutionContext {
+    constructor() {
+        this.id = uniqueId();
+        this.methods = [];
+        this.result = new ProvableMethodExecutionResult();
+    }
+    // TODO See if we should make this class generic, bc I think we can persist the type
+    /**
+     * 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
+     */
+    setProver(prover) {
+        this.result.prover = prover;
+    }
+    /**
+     * Adds a method to the method execution stack, reseting the execution context
+     * in a case a new top-level (non nested) method call is made.
+     *
+     * @param methodName - Name of the method being captured in the context
+     */
+    beforeMethod(moduleName, methodName, args) {
+        if (this.isFinished) {
+            this.clear();
+            this.result.moduleName = moduleName;
+            this.result.methodName = methodName;
+            this.result.args = args;
+        }
+        this.methods.push(methodName);
+    }
+    /**
+     * Removes the latest method from the execution context stack,
+     * keeping track of the amount of 'unfinished' methods. Allowing
+     * for the context to distinguish between top-level and nested method calls.
+     */
+    afterMethod() {
+        this.methods.pop();
+    }
+    get isTopLevel() {
+        return this.methods.length === 1;
+    }
+    get isFinished() {
+        return this.methods.length === 0;
+    }
+    /**
+     * @returns - Current execution context state
+     */
+    current() {
+        return {
+            isFinished: this.isFinished,
+            result: this.result,
+        };
+    }
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear() {
+        this.result = new ProvableMethodExecutionResult();
+    }
+};
+ProvableMethodExecutionContext = __decorate([
+    singleton()
+], ProvableMethodExecutionContext);
+//# sourceMappingURL=ProvableMethodExecutionContext.js.map

package/dist/zkProgrammable/ProvableMethodExecutionContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableMethodExecutionContext.js","sourceRoot":"","sources":["../../src/zkProgrammable/ProvableMethodExecutionContext.ts"],"names":[],"mappings":";;;;;;AACA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,QAAQ,MAAM,iBAAiB,CAAC;AAIvC,MAAM,MAAM,GAAG;IACb,wBAAwB,EAAE,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,+BAA+B,CAAC;IAE1E,YAAY,EAAE,CAAC,UAAkB,EAAE,UAAkB,EAAE,EAAE,CACvD,IAAI,KAAK,CACP,uBAAuB,UAAU,IAAI,UAAU,4CAA4C,CAC5F;CACJ,CAAC;AAEF,MAAM,OAAO,6BAA6B;IASjC,KAAK,CAAC,KAAK;QAGhB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,yEAAyE;YACzE,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBACxC,MAAM,MAAM,CAAC,wBAAwB,EAAE,CAAC;aACzC;YACD,MAAM,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;SAC7D;QAED,qDAAqD;QACrD,yEAAyE;QACzE,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,CAAc,CAAC;IAC5C,CAAC;CACF;AAED;;;;GAIG;AAEI,WAAM,8BAA8B,GAApC,MAAM,8BAA8B;IAApC;QACE,OAAE,GAAG,QAAQ,EAAE,CAAC;QAEhB,YAAO,GAAa,EAAE,CAAC;QAEvB,WAAM,GACX,IAAI,6BAA6B,EAAE,CAAC;IAoExC,CAAC;IAlEC,oFAAoF;IACpF;;;;;;OAMG;IACI,SAAS,CAAC,MAA8C;QAC7D,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACI,YAAY,CACjB,UAAkB,EAClB,UAAkB,EAClB,IAAmB;QAEnB,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC;YACpC,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC;YACpC,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;SACzB;QAED,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACI,WAAW;QAChB,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC;IACnC,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,KAAK;QACV,IAAI,CAAC,MAAM,GAAG,IAAI,6BAA6B,EAAE,CAAC;IACpD,CAAC;CACF,CAAA;AA1EY,8BAA8B;IAD1C,SAAS,EAAE;GACC,8BAA8B,CA0E1C"}

package/dist/zkProgrammable/ZkProgrammable.d.ts

@@ -0,0 +1,40 @@
+import { ZkProgram, FlexibleProvablePure, Proof, Field, Provable } from "o1js";
+import type { CompileRegistry } from "../compiling/CompileRegistry";
+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> {
+    name: string;
+    compile: Compile;
+    verify: Verify<PublicInput, PublicOutput>;
+    Proof: ReturnType<typeof ZkProgram.Proof<FlexibleProvablePure<PublicInput>, FlexibleProvablePure<PublicOutput>>>;
+    methods: Record<string, ((...args: any) => Promise<Proof<PublicInput, PublicOutput>>) | ((publicInput: PublicInput, ...args: any) => Promise<Proof<PublicInput, PublicOutput>>)>;
+    analyzeMethods: () => Promise<Record<string, Awaited<ReturnType<typeof Provable.constraintSystem>>>>;
+}
+export declare function verifyToMockable<PublicInput, PublicOutput>(verify: Verify<PublicInput, PublicOutput>, { areProofsEnabled }: AreProofsEnabled): (proof: Proof<PublicInput, PublicOutput>) => Promise<boolean>;
+export declare const MOCK_VERIFICATION_KEY: import("o1js/dist/node/lib/proof-system/zkprogram").VerificationKey;
+export declare function compileToMockable(compile: Compile, { areProofsEnabled }: AreProofsEnabled): () => Promise<CompileArtifact>;
+export declare abstract class ZkProgrammable<PublicInput = undefined, PublicOutput = void> {
+    abstract get areProofsEnabled(): AreProofsEnabled | undefined;
+    abstract zkProgramFactory(): PlainZkProgram<PublicInput, PublicOutput>[];
+    private zkProgramSingleton?;
+    get zkProgram(): PlainZkProgram<PublicInput, PublicOutput>[];
+    compile(registry: CompileRegistry): Promise<Record<string, CompileArtifact>>;
+}
+export interface WithZkProgrammable<PublicInput = undefined, PublicOutput = void> {
+    zkProgrammable: ZkProgrammable<PublicInput, PublicOutput>;
+}
+//# sourceMappingURL=ZkProgrammable.d.ts.map

package/dist/zkProgrammable/ZkProgrammable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZkProgrammable.d.ts","sourceRoot":"","sources":["../../src/zkProgrammable/ZkProgrammable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAM/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AASpE,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE;QACf,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,KAAK,CAAC;KACb,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,gBAAgB,EAAE,CAAC,gBAAgB,EAAE,OAAO,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,MAAM,CAAC,WAAW,EAAE,YAAY;IAC/C,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc,CAAC,WAAW,GAAG,SAAS,EAAE,YAAY,GAAG,IAAI;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;IAC1C,KAAK,EAAE,UAAU,CACf,OAAO,SAAS,CAAC,KAAK,CACpB,oBAAoB,CAAC,WAAW,CAAC,EACjC,oBAAoB,CAAC,YAAY,CAAC,CACnC,CACF,CAAC;IACF,OAAO,EAAE,MAAM,CACb,MAAM,EACJ,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC,GAC7D,CAAC,CACC,WAAW,EAAE,WAAW,EACxB,GAAG,IAAI,EAAE,GAAG,KACT,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC,CAClD,CAAC;IACF,cAAc,EAAE,MAAM,OAAO,CAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC,CACtE,CAAC;CACH;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,YAAY,EACxD,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,YAAY,CAAC,EACzC,EAAE,gBAAgB,EAAE,EAAE,gBAAgB,WAEjB,MAAM,WAAW,EAAE,YAAY,CAAC,sBAiBtD;AAED,eAAO,MAAM,qBAAqB,qEAAyB,CAAC;AAE5D,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,EAAE,gBAAgB,EAAE,EAAE,gBAAgB,GACrC,MAAM,OAAO,CAAC,eAAe,CAAC,CAUhC;AAED,8BAAsB,cAAc,CAClC,WAAW,GAAG,SAAS,EACvB,YAAY,GAAG,IAAI;IAEnB,aAAoB,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAAC;aAErD,gBAAgB,IAAI,cAAc,CAChD,WAAW,EACX,YAAY,CACb,EAAE;IAEH,OAAO,CAAC,kBAAkB,CAAC,CAA8C;IAEzE,IACW,SAAS,IAAI,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,EAAE,CAelE;IAEY,OAAO,CAAC,QAAQ,EAAE,eAAe;CAc/C;AAED,MAAM,WAAW,kBAAkB,CACjC,WAAW,GAAG,SAAS,EACvB,YAAY,GAAG,IAAI;IAEnB,cAAc,EAAE,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;CAC3D"}

package/dist/zkProgrammable/ZkProgrammable.js

@@ -0,0 +1,79 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Memoize } from "typescript-memoize";
+import { log } from "../log";
+import { dummyVerificationKey } from "../dummyVerificationKey";
+import { reduceSequential } from "../utils";
+import { MOCK_PROOF } from "./provableMethod";
+const errors = {
+    areProofsEnabledNotSet: (name) => new Error(`AreProofsEnabled was not injected for: ${name}`),
+};
+export function verifyToMockable(verify, { areProofsEnabled }) {
+    return async (proof) => {
+        if (areProofsEnabled) {
+            let verified = false;
+            try {
+                verified = await verify(proof);
+            }
+            catch (error) {
+                // silently fail verification
+                log.error(error);
+                verified = false;
+            }
+            return verified;
+        }
+        return proof.proof === MOCK_PROOF;
+    };
+}
+export const MOCK_VERIFICATION_KEY = dummyVerificationKey();
+export function compileToMockable(compile, { areProofsEnabled }) {
+    return async () => {
+        if (areProofsEnabled) {
+            return await compile();
+        }
+        return {
+            verificationKey: MOCK_VERIFICATION_KEY,
+        };
+    };
+}
+export class ZkProgrammable {
+    get zkProgram() {
+        if (this.zkProgramSingleton === undefined) {
+            this.zkProgramSingleton = this.zkProgramFactory();
+        }
+        return this.zkProgramSingleton.map((bucket) => {
+            if (!this.areProofsEnabled) {
+                throw errors.areProofsEnabledNotSet(this.constructor.name);
+            }
+            return {
+                ...bucket,
+                verify: verifyToMockable(bucket.verify, this.areProofsEnabled),
+                compile: compileToMockable(bucket.compile, this.areProofsEnabled),
+            };
+        });
+    }
+    async compile(registry) {
+        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
+        {});
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], ZkProgrammable.prototype, "zkProgram", null);
+//# sourceMappingURL=ZkProgrammable.js.map

package/dist/zkProgrammable/ZkProgrammable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZkProgrammable.js","sourceRoot":"","sources":["../../src/zkProgrammable/ZkProgrammable.ts"],"names":[],"mappings":";;;;;;;;;AACA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,MAAM,MAAM,GAAG;IACb,sBAAsB,EAAE,CAAC,IAAY,EAAE,EAAE,CACvC,IAAI,KAAK,CAAC,0CAA0C,IAAI,EAAE,CAAC;CAC9D,CAAC;AA6CF,MAAM,UAAU,gBAAgB,CAC9B,MAAyC,EACzC,EAAE,gBAAgB,EAAoB;IAEtC,OAAO,KAAK,EAAE,KAAuC,EAAE,EAAE;QACvD,IAAI,gBAAgB,EAAE;YACpB,IAAI,QAAQ,GAAG,KAAK,CAAC;YAErB,IAAI;gBACF,QAAQ,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,CAAC;aAChC;YAAC,OAAO,KAAc,EAAE;gBACvB,6BAA6B;gBAC7B,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACjB,QAAQ,GAAG,KAAK,CAAC;aAClB;YAED,OAAO,QAAQ,CAAC;SACjB;QAED,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU,CAAC;IACpC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,qBAAqB,GAAG,oBAAoB,EAAE,CAAC;AAE5D,MAAM,UAAU,iBAAiB,CAC/B,OAAgB,EAChB,EAAE,gBAAgB,EAAoB;IAEtC,OAAO,KAAK,IAAI,EAAE;QAChB,IAAI,gBAAgB,EAAE;YACpB,OAAO,MAAM,OAAO,EAAE,CAAC;SACxB;QAED,OAAO;YACL,eAAe,EAAE,qBAAqB;SACvC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,OAAgB,cAAc;IAalC,IACW,SAAS;QAClB,IAAI,IAAI,CAAC,kBAAkB,KAAK,SAAS,EAAE;YACzC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;SACnD;QAED,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YAC5C,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;gBAC1B,MAAM,MAAM,CAAC,sBAAsB,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;aAC5D;YACD,OAAO;gBACL,GAAG,MAAM;gBACT,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC;gBAC9D,OAAO,EAAE,iBAAiB,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC;aAClE,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,QAAyB;QAC5C,OAAO,MAAM,gBAAgB,CAC3B,IAAI,CAAC,SAAS,EACd,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE;YACrB,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAC/C,OAAO;gBACL,GAAG,GAAG;gBACN,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM;aACvB,CAAC;QACJ,CAAC;QACD,yEAAyE;QACzE,EAAqC,CACtC,CAAC;IACJ,CAAC;CACF;AAhCC;IAAC,OAAO,EAAE;;;+CAgBT"}

package/dist/zkProgrammable/provableMethod.d.ts

@@ -0,0 +1,19 @@
+import { Proof, DynamicProof } from "o1js";
+import { ProvableMethodExecutionContext } from "./ProvableMethodExecutionContext";
+import type { WithZkProgrammable, ZkProgrammable } from "./ZkProgrammable";
+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 declare const MOCK_PROOF = "mock-proof";
+export declare function toProver(methodName: string, simulatedMethod: DecoratedMethod, isFirstParameterPublicInput: boolean, ...args: ArgumentTypes): (this: ZkProgrammable<any, any>) => Promise<Proof<any, any>>;
+/**
+ * Decorates a provable method on a 'prover class', depending on
+ * if proofs are enabled or not, either runs the respective zkProgram prover,
+ * or simulates the method execution and issues a mock proof.
+ *
+ * @param isFirstParameterPublicInput
+ * @param executionContext
+ * @returns
+ */
+export declare function provableMethod(isFirstParameterPublicInput?: boolean, executionContext?: ProvableMethodExecutionContext): <Target extends ZkProgrammable<any, any> | WithZkProgrammable<any, any>>(target: Target, methodName: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any> | any>) => TypedPropertyDescriptor<(...args: any[]) => Promise<any> | any>;
+//# sourceMappingURL=provableMethod.d.ts.map

package/dist/zkProgrammable/provableMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provableMethod.d.ts","sourceRoot":"","sources":["../../src/zkProgrammable/provableMethod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAG3C,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAG3E,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAC/D,MAAM,MAAM,aAAa,GAAG,CACxB,aAAa,GACb,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,GACvB,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CACjC,EAAE,CAAC;AAEJ,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE3E,eAAO,MAAM,UAAU,eAAe,CAAC;AAGvC,wBAAgB,QAAQ,CACtB,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,eAAe,EAChC,2BAA2B,EAAE,OAAO,EACpC,GAAG,IAAI,EAAE,aAAa,UAEa,eAAe,GAAG,EAAE,GAAG,CAAC,8BAiC5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,2BAA2B,UAAO,EAClC,gBAAgB,GAAE,8BAEjB,wGAMa,MAAM,gDAC4B,GAAG,EAAE,KAAK,QAAQ,GAAG,CAAC,GAAG,GAAG,wCAA5B,GAAG,EAAE,KAAK,QAAQ,GAAG,CAAC,GAAG,GAAG,EA2C7E"}

package/dist/zkProgrammable/provableMethod.js

@@ -0,0 +1,71 @@
+import { container } from "tsyringe";
+import { ProvableMethodExecutionContext } from "./ProvableMethodExecutionContext";
+export const MOCK_PROOF = "mock-proof";
+// (await Proof.dummy(Field(0), Field(0), 2)).proof as string;
+export function toProver(methodName, simulatedMethod, isFirstParameterPublicInput, ...args) {
+    return async function prover() {
+        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
+        const publicOutput = await Reflect.apply(simulatedMethod, this, args);
+        return new zkProgram.Proof({
+            proof: MOCK_PROOF,
+            // TODO: provide undefined if public input is not used
+            publicInput: isFirstParameterPublicInput ? args[0] : undefined,
+            publicOutput,
+            /**
+             * We set this to the max possible number, to avoid having
+             * to manually count in-circuit proof verifications
+             */
+            maxProofsVerified: 2,
+        });
+    };
+}
+/**
+ * Decorates a provable method on a 'prover class', depending on
+ * if proofs are enabled or not, either runs the respective zkProgram prover,
+ * or simulates the method execution and issues a mock proof.
+ *
+ * @param isFirstParameterPublicInput
+ * @param executionContext
+ * @returns
+ */
+export function provableMethod(isFirstParameterPublicInput = true, executionContext = container.resolve(ProvableMethodExecutionContext)) {
+    return (target, methodName, descriptor) => {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const simulatedMethod = descriptor.value;
+        descriptor.value = async function value(...args) {
+            const prover = toProver(methodName, simulatedMethod, isFirstParameterPublicInput, ...args);
+            executionContext.beforeMethod(this.constructor.name, methodName, args);
+            /**
+             * Check if the method is called at the top level,
+             * if yes then create a prover.
+             */
+            if (executionContext.isTopLevel) {
+                executionContext.setProver(prover.bind(this));
+            }
+            /**
+             * Regardless of if the method is called from the top level
+             * or not, execute its simulated (Javascript) version and
+             * return the result.
+             */
+            let result;
+            try {
+                result = Reflect.apply(simulatedMethod, this, args);
+            }
+            finally {
+                executionContext.afterMethod();
+            }
+            return result;
+        };
+        return descriptor;
+    };
+}
+//# sourceMappingURL=provableMethod.js.map

package/dist/zkProgrammable/provableMethod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provableMethod.js","sourceRoot":"","sources":["../../src/zkProgrammable/provableMethod.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAalF,MAAM,CAAC,MAAM,UAAU,GAAG,YAAY,CAAC;AACvC,8DAA8D;AAE9D,MAAM,UAAU,QAAQ,CACtB,UAAkB,EAClB,eAAgC,EAChC,2BAAoC,EACpC,GAAG,IAAmB;IAEtB,OAAO,KAAK,UAAU,MAAM;QAC1B,MAAM,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC,gBAAiB,CAAC;QAEpD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAC7C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAC/C,CAAC;QAEF,IAAI,SAAS,KAAK,SAAS,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;SAChD;QAED,IAAI,gBAAgB,EAAE;YACpB,MAAM,qBAAqB,GAAG,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAC5D,OAAO,MAAM,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;SAC/D;QAED,4DAA4D;QAC5D,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAEtE,OAAO,IAAI,SAAS,CAAC,KAAK,CAAC;YACzB,KAAK,EAAE,UAAU;YAEjB,sDAAsD;YACtD,WAAW,EAAE,2BAA2B,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;YAC9D,YAAY;YAEZ;;;eAGG;YACH,iBAAiB,EAAE,CAAC;SACrB,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,2BAA2B,GAAG,IAAI,EAClC,mBAAmD,SAAS,CAAC,OAAO,CAClE,8BAA8B,CAC/B;IAED,OAAO,CAGL,MAAc,EACd,UAAkB,EAClB,UAA2E,EAC3E,EAAE;QACF,yEAAyE;QACzE,MAAM,eAAe,GAAG,UAAU,CAAC,KAAwB,CAAC;QAE5D,UAAU,CAAC,KAAK,GAAG,KAAK,UAAU,KAAK,CAErC,GAAG,IAAmB;YAEtB,MAAM,MAAM,GAAG,QAAQ,CACrB,UAAU,EACV,eAAe,EACf,2BAA2B,EAC3B,GAAG,IAAI,CACR,CAAC;YAEF,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;YAEvE;;;eAGG;YACH,IAAI,gBAAgB,CAAC,UAAU,EAAE;gBAC/B,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;aAC/C;YAED;;;;eAIG;YACH,IAAI,MAAe,CAAC;YACpB,IAAI;gBACF,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;aACrD;oBAAS;gBACR,gBAAgB,CAAC,WAAW,EAAE,CAAC;aAChC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/jest.config.cjs

@@ -0,0 +1,12 @@
+// @ts-ignore
+const config = require("../../jest.config.cjs");
+
+module.exports = {
+  ...config,
+  collectCoverageFrom: [
+    "packages/common/src/**",
+    "!**/node_modules/**",
+    "!**/dist/**",
+  ],
+  coverageDirectory: "coverage/common",
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@proto-kit/common",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "version": "0.1.1-develop.0+19469b2",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "lint": "eslint ./src ./test",
+    "test:file": "node --experimental-vm-modules --experimental-wasm-modules ../../node_modules/jest/bin/jest.js",
+    "test": "npm run test:file -- ./test/**",
+    "test:watch": "npm run test:file -- ./test/** --watch"
+  },
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "loglevel": "^1.8.1",
+    "reflect-metadata": "^0.1.13",
+    "typescript-memoize": "^1.1.1"
+  },
+  "peerDependencies": {
+    "o1js": "^1.6.0",
+    "tsyringe": "^4.7.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/lodash": "^4.14.194"
+  },
+  "gitHead": "19469b285cd6953e6c621875d789959b521842c3"
+}

package/src/compiling/AtomicCompileHelper.ts

@@ -0,0 +1,62 @@
+import {
+  AreProofsEnabled,
+  CompileArtifact,
+  MOCK_VERIFICATION_KEY,
+} from "../zkProgrammable/ZkProgrammable";
+import { isSubtypeOfName } from "../utils";
+import { TypedClass } from "../types";
+import { log } from "../log";
+
+export type ArtifactRecord = Record<string, CompileArtifact>;
+
+export type CompileTarget = {
+  name: string;
+  compile: () => Promise<CompileArtifact>;
+};
+
+export class AtomicCompileHelper {
+  public constructor(private readonly areProofsEnabled: AreProofsEnabled) {}
+
+  private compilationPromises: {
+    [key: string]: Promise<CompileArtifact>;
+  } = {};
+
+  public async compileContract(
+    contract: CompileTarget,
+    overrideProofsEnabled?: boolean
+  ): Promise<CompileArtifact> {
+    let newPromise = false;
+    const { name } = contract;
+    if (this.compilationPromises[name] === undefined) {
+      const proofsEnabled =
+        overrideProofsEnabled ?? this.areProofsEnabled.areProofsEnabled;
+
+      // We only care about proofs enabled here if it's a contract, because
+      // in all other cases, ZkProgrammable already handles this switch, and we
+      // want to preserve the artifact layout (which might be more than one
+      // entry for ZkProgrammables)
+      if (
+        proofsEnabled ||
+        !isSubtypeOfName(
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          contract as unknown as TypedClass<any>,
+          "SmartContract"
+        )
+      ) {
+        log.time(`Compiling ${name}`);
+        this.compilationPromises[name] = contract.compile();
+        newPromise = true;
+      } else {
+        log.trace(`Compiling ${name} - mock`);
+        this.compilationPromises[name] = Promise.resolve({
+          verificationKey: MOCK_VERIFICATION_KEY,
+        });
+      }
+    }
+    const result = await this.compilationPromises[name];
+    if (newPromise) {
+      log.timeEnd.info(`Compiling ${name}`);
+    }
+    return result;
+  }
+}

package/src/compiling/CompilableModule.ts

@@ -0,0 +1,6 @@
+import type { CompileRegistry } from "./CompileRegistry";
+import type { ArtifactRecord } from "./AtomicCompileHelper";
+
+export interface CompilableModule {
+  compile(registry: CompileRegistry): Promise<ArtifactRecord | void>;
+}

package/src/compiling/CompileRegistry.ts

@@ -0,0 +1,78 @@
+import { inject, injectable, singleton } from "tsyringe";
+
+import {
+  AreProofsEnabled,
+  CompileArtifact,
+} from "../zkProgrammable/ZkProgrammable";
+
+import {
+  ArtifactRecord,
+  AtomicCompileHelper,
+  CompileTarget,
+} from "./AtomicCompileHelper";
+
+/**
+ * The CompileRegistry compiles "compilable modules"
+ * (i.e. zkprograms, contracts or contractmodules)
+ * while making sure they don't get compiled twice in the same process in parallel.
+ */
+@injectable()
+@singleton()
+export class CompileRegistry {
+  public constructor(
+    @inject("AreProofsEnabled")
+    private readonly areProofsEnabled: AreProofsEnabled
+  ) {
+    this.compiler = new AtomicCompileHelper(this.areProofsEnabled);
+  }
+
+  private compiler: AtomicCompileHelper;
+
+  private artifacts: ArtifactRecord = {};
+
+  private inForceProverBlock = false;
+
+  /**
+   * This function forces compilation even if the artifact itself is in the registry.
+   * Basically the statement is: The artifact along is not enough, we need to
+   * actually have the prover compiled.
+   * This is true for non-sideloaded circuit dependencies.
+   */
+  public async forceProverExists(
+    f: (registry: CompileRegistry) => Promise<void>
+  ) {
+    this.inForceProverBlock = true;
+    await f(this);
+    this.inForceProverBlock = false;
+  }
+
+  public async compile(target: CompileTarget) {
+    if (this.artifacts[target.name] === undefined || this.inForceProverBlock) {
+      const artifact = await this.compiler.compileContract(target);
+      this.artifacts[target.name] = artifact;
+      return artifact;
+    }
+    return this.artifacts[target.name];
+  }
+
+  public getArtifact(name: string): CompileArtifact | undefined {
+    if (this.artifacts[name] === undefined) {
+      throw new Error(
+        `Artifact for ${name} not available, did you compile it via the CompileRegistry?`
+      );
+    }
+
+    return this.artifacts[name];
+  }
+
+  public addArtifactsRaw(artifacts: ArtifactRecord) {
+    this.artifacts = {
+      ...this.artifacts,
+      ...artifacts,
+    };
+  }
+
+  public getAllArtifacts() {
+    return this.artifacts;
+  }
+}

package/src/compiling/services/ChildVerificationKeyService.ts

@@ -0,0 +1,26 @@
+import { injectable, Lifecycle, scoped } from "tsyringe";
+
+import { CompileRegistry } from "../CompileRegistry";
+
+@injectable()
+@scoped(Lifecycle.ContainerScoped)
+export class ChildVerificationKeyService {
+  private compileRegistry?: CompileRegistry;
+
+  public setCompileRegistry(registry: CompileRegistry) {
+    this.compileRegistry = registry;
+  }
+
+  public getVerificationKey(name: string) {
+    if (this.compileRegistry === undefined) {
+      throw new Error("CompileRegistry hasn't been set yet");
+    }
+    const artifact = this.compileRegistry.getArtifact(name);
+    if (artifact === undefined) {
+      throw new Error(
+        `Verification Key for child program ${name} not found in registry`
+      );
+    }
+    return artifact.verificationKey;
+  }
+}

package/src/config/ChildContainerCreatable.ts

@@ -0,0 +1,5 @@
+import { ChildContainerProvider } from "./ChildContainerProvider";
+
+export interface ChildContainerCreatable {
+  create: (childContainerProvider: ChildContainerProvider) => void;
+}

package/src/config/ChildContainerProvider.ts

@@ -0,0 +1,5 @@
+import { DependencyContainer } from "tsyringe";
+
+export interface ChildContainerProvider {
+  (): DependencyContainer;
+}