@proto-kit/common 0.1.1-develop.1086

package/dist/utils.js

@@ -0,0 +1,73 @@
+import { Field, Poseidon, } from "o1js";
+export function requireTrue(condition, errorOrFunction) {
+    if (!condition) {
+        throw typeof errorOrFunction === "function"
+            ? errorOrFunction()
+            : errorOrFunction;
+    }
+}
+export function range(startOrEnd, endOrNothing) {
+    let end = endOrNothing;
+    let start = startOrEnd;
+    if (end === undefined) {
+        end = startOrEnd;
+        start = 0;
+    }
+    return Array.from({ length: end - start }, (ignored, index) => index + start);
+}
+export function reduceSequential(array, callbackfn, initialValue) {
+    return array.reduce(async (previousPromise, current, index, arr) => {
+        const previous = await previousPromise;
+        return await callbackfn(previous, current, index, arr);
+    }, Promise.resolve(initialValue));
+}
+export function mapSequential(array, f) {
+    return array.reduce(async (r, element, index, a) => {
+        const ret = await r;
+        const next = await f(element, index, a);
+        ret.push(next);
+        return ret;
+    }, Promise.resolve([]));
+}
+/**
+ * Computes a dummy value for the given value type.
+ *
+ * @param valueType - Value type to generate the dummy value for
+ * @returns Dummy value for the given value type
+ */
+export function dummyValue(valueType) {
+    const length = valueType.sizeInFields();
+    const fields = Array.from({ length }, () => Field(0));
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return valueType.fromFields(fields);
+}
+export function noop() { }
+export async function sleep(ms) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function filterNonNull(value) {
+    return value !== null;
+}
+export function filterNonUndefined(value) {
+    return value !== undefined;
+}
+const encoder = new TextEncoder();
+// Copied from o1js binable.ts:317
+export function prefixToField(prefix) {
+    const fieldSize = Field.sizeInBytes;
+    if (prefix.length >= fieldSize)
+        throw Error("prefix too long");
+    const stringBytes = [...encoder.encode(prefix)];
+    return Field.fromBytes(stringBytes.concat(Array(fieldSize - stringBytes.length).fill(0)));
+}
+export function hashWithPrefix(prefix, input) {
+    const salt = Poseidon.update([Field(0), Field(0), Field(0)], [prefixToField(prefix)]);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return Poseidon.update(salt, input)[0];
+}
+// end copy
+export function expectDefined(value) {
+    expect(value).toBeDefined();
+}

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,96 @@
+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);

package/dist/zkProgrammable/ZkProgrammable.d.ts

@@ -0,0 +1,39 @@
+import { ZkProgram, FlexibleProvablePure, Proof, Field, Provable } from "o1js";
+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<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: {
+    data: string;
+    hash: import("o1js/dist/node/lib/provable/field").Field;
+};
+export declare function compileToMockable(compile: Compile, { areProofsEnabled }: AreProofsEnabled): () => Promise<CompileArtifact>;
+export declare abstract class ZkProgrammable<PublicInput = undefined, PublicOutput = void> {
+    abstract get appChain(): AreProofsEnabled | undefined;
+    abstract zkProgramFactory(): PlainZkProgram<PublicInput, PublicOutput>[];
+    get zkProgram(): PlainZkProgram<PublicInput, PublicOutput>[];
+}
+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;AAY/E,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,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;;;CAGjC,CAAC;AAEF,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,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAAC;aAE7C,gBAAgB,IAAI,cAAc,CAChD,WAAW,EACX,YAAY,CACb,EAAE;IAEH,IACW,SAAS,IAAI,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,EAAE,CAalE;CACF;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,67 @@
+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 { Field } from "o1js";
+import { Memoize } from "typescript-memoize";
+import { log } from "../log";
+import { MOCK_PROOF } from "./provableMethod";
+const errors = {
+    appChainNotSet: (name) => new Error(`Appchain 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 = {
+    data: "mock-verification-key",
+    hash: Field(0),
+};
+export function compileToMockable(compile, { areProofsEnabled }) {
+    return async () => {
+        if (areProofsEnabled) {
+            return await compile();
+        }
+        return {
+            verificationKey: MOCK_VERIFICATION_KEY,
+        };
+    };
+}
+export class ZkProgrammable {
+    get zkProgram() {
+        const zkProgram = this.zkProgramFactory();
+        return zkProgram.map((bucket) => {
+            if (!this.appChain) {
+                throw errors.appChainNotSet(this.constructor.name);
+            }
+            return {
+                ...bucket,
+                verify: verifyToMockable(bucket.verify, this.appChain),
+                compile: compileToMockable(bucket.compile, this.appChain),
+            };
+        });
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], ZkProgrammable.prototype, "zkProgram", null);

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;AAEvC,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,73 @@
+import { container } from "tsyringe";
+import { ProvableMethodExecutionContext } from "./ProvableMethodExecutionContext";
+export const MOCK_PROOF = "mock-proof";
+export function toProver(methodName, simulatedMethod, isFirstParameterPublicInput, ...args) {
+    return async function prover() {
+        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);
+                }
+            }
+        }
+        // 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,
+            // 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;
+    };
+}

package/jest.config.cjs

@@ -0,0 +1 @@
+module.exports = require("../../jest.config.cjs");

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@proto-kit/common",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "version": "0.1.1-develop.1086+eeb4563a",
+  "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 --experimental-wasm-threads ../../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.1.0",
+    "tsyringe": "^4.7.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/lodash": "^4.14.194"
+  },
+  "gitHead": "eeb4563a685b29525358ec7404fa9f0251d258d4"
+}

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;
+}

package/src/config/ConfigurableModule.ts

@@ -0,0 +1,57 @@
+import { noop } from "../utils";
+
+import { ChildContainerProvider } from "./ChildContainerProvider";
+import type { BaseModuleInstanceType } from "./ModuleContainer";
+
+const errors = {
+  configNotSet: (moduleName: string) =>
+    new Error(
+      `Trying to retrieve config of ${moduleName}, which was not yet set`
+    ),
+};
+
+// defines how presets can be provided, either a function or a record
+export type Preset<Config> = Config | ((...args: unknown[]) => Config);
+export type Presets<Config> = Record<string, Preset<Config>>;
+
+// describes the interface of a configurable module
+export interface Configurable<Config> {
+  config: Config;
+}
+
+export type NoConfig = Record<never, never>;
+
+/**
+ * Used by various module sub-types that may need to be configured
+ */
+export class ConfigurableModule<Config = NoConfig>
+  implements BaseModuleInstanceType
+{
+  /**
+   * Store the config separately, so that we can apply additional
+   * checks when retrieving it via the getter
+   */
+  protected currentConfig: Config | undefined;
+
+  // retrieve the existing config
+  public get config(): Config {
+    if (this.currentConfig === undefined) {
+      throw errors.configNotSet(this.constructor.name);
+    }
+    return this.currentConfig;
+  }
+
+  // set the config
+  public set config(config: Config) {
+    this.currentConfig = config;
+  }
+
+  public create(childContainerProvider: ChildContainerProvider): void {
+    noop();
+  }
+}
+
+// Helps ensure that the target class implements static presets
+export interface StaticConfigurableModule<Config> {
+  presets: Presets<Config>;
+}