@proto-kit/module 0.1.1-develop.600 → 0.1.1-develop.833

package/dist/runtime/RuntimeModule.d.ts

@@ -1,5 +1,5 @@
 import { ConfigurableModule, NoConfig, Presets } from "@proto-kit/common";
-import { NetworkState, RuntimeTransaction } from "@proto-kit/protocol";
+import { NetworkState, RuntimeTransaction, RuntimeMethodExecutionData } from "@proto-kit/protocol";
 import { RuntimeEnvironment } from "./RuntimeEnvironment";
 /**
  * Base class for runtime modules providing the necessary utilities.
@@ -19,7 +19,7 @@ export declare class RuntimeModule<Config = NoConfig> extends ConfigurableModule
     name?: string;
     runtime?: RuntimeEnvironment;
     constructor();
-    private getInputs;
+    getInputs(): RuntimeMethodExecutionData;
     get transaction(): RuntimeTransaction;
     get network(): NetworkState;
 }

package/dist/runtime/RuntimeModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuntimeModule.d.ts","sourceRoot":"","sources":["../../src/runtime/RuntimeModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE1E,OAAO,EACL,YAAY,EACZ,kBAAkB,EAInB,MAAM,qBAAqB,CAAC;AAS7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAM1D;;GAEG;AACH,qBACa,aAAa,CACxB,MAAM,GAAG,QAAQ,CACjB,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IAClC,OAAc,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAM;IAE7C;;OAEG;IACH,SAAgB,kBAAkB,EAAE,MAAM,EAAE,CAAM;IAElD;;;;OAIG;IACI,eAAe,UAAQ;IAEvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,OAAO,CAAC,EAAE,kBAAkB,CAAC;;IAYpC,OAAO,CAAC,SAAS;IAWjB,IAAW,WAAW,IAAI,kBAAkB,CAE3C;IAED,IAAW,OAAO,IAAI,YAAY,CAEjC;CACF"}
+{"version":3,"file":"RuntimeModule.d.ts","sourceRoot":"","sources":["../../src/runtime/RuntimeModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE1E,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,0BAA0B,EAE3B,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAM1D;;GAEG;AACH,qBACa,aAAa,CACxB,MAAM,GAAG,QAAQ,CACjB,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IAClC,OAAc,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAM;IAE7C;;OAEG;IACH,SAAgB,kBAAkB,EAAE,MAAM,EAAE,CAAM;IAElD;;;;OAIG;IACI,eAAe,UAAQ;IAEvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,OAAO,CAAC,EAAE,kBAAkB,CAAC;;IAY7B,SAAS,IAAI,0BAA0B;IAa9C,IAAW,WAAW,IAAI,kBAAkB,CAE3C;IAED,IAAW,OAAO,IAAI,YAAY,CAEjC;CACF"}

package/dist/runtime/RuntimeModule.js

@@ -9,7 +9,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { ConfigurableModule } from "@proto-kit/common";
 import { container, injectable } from "tsyringe";
-import { RuntimeMethodExecutionContext, } from "@proto-kit/protocol";
+import { RuntimeMethodExecutionContext, RuntimeMethodExecutionDataStruct, } from "@proto-kit/protocol";
+import { Provable } from "o1js";
 import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
 const errors = {
     inputDataNotSet: () => new Error("Input data for runtime execution not set"),
@@ -17,7 +18,7 @@ const errors = {
 /**
  * Base class for runtime modules providing the necessary utilities.
  */
-let RuntimeModule = class RuntimeModule extends ConfigurableModule {
+export let RuntimeModule = class RuntimeModule extends ConfigurableModule {
     constructor() {
         super();
         /**
@@ -35,11 +36,13 @@ let RuntimeModule = class RuntimeModule extends ConfigurableModule {
         this.runtimeMethodNames = methodNames ?? [];
     }
     getInputs() {
-        const { input } = container.resolve(RuntimeMethodExecutionContext);
-        if (input === undefined) {
-            throw errors.inputDataNotSet();
-        }
-        return input;
+        return Provable.witness(RuntimeMethodExecutionDataStruct, () => {
+            const { input } = container.resolve(RuntimeMethodExecutionContext);
+            if (input === undefined) {
+                throw errors.inputDataNotSet();
+            }
+            return input;
+        });
     }
     get transaction() {
         return this.getInputs().transaction;
@@ -53,4 +56,3 @@ RuntimeModule = __decorate([
     injectable(),
     __metadata("design:paramtypes", [])
 ], RuntimeModule);
-export { RuntimeModule };

package/dist/src/factories/MethodIdFactory.d.ts

@@ -0,0 +1,10 @@
+import { DependencyFactory } from "@proto-kit/common";
+import { MethodIdResolver } from "../runtime/MethodIdResolver";
+export declare class MethodIdFactory implements DependencyFactory {
+    dependencies(): {
+        methodIdResolver: {
+            useClass: typeof MethodIdResolver;
+        };
+    };
+}
+//# sourceMappingURL=MethodIdFactory.d.ts.map

package/dist/src/factories/MethodIdFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodIdFactory.d.ts","sourceRoot":"","sources":["../../../src/factories/MethodIdFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAoB,MAAM,mBAAmB,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,qBAAa,eAAgB,YAAW,iBAAiB;IAChD,YAAY;;;;;CAOpB"}

package/dist/src/factories/MethodIdFactory.js

@@ -0,0 +1,10 @@
+import { MethodIdResolver } from "../runtime/MethodIdResolver";
+export class MethodIdFactory {
+    dependencies() {
+        return {
+            methodIdResolver: {
+                useClass: MethodIdResolver,
+            },
+        };
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./method/runtimeMethod";
+export * from "./module/decorator";
+export * from "./runtime/RuntimeModule";
+export * from "./runtime/RuntimeEnvironment";
+export * from "./runtime/Runtime";
+export * from "./state/InMemoryStateService";
+export * from "./state/decorator";
+export * from "./method/MethodParameterEncoder";
+export * from "./runtime/MethodIdResolver";
+export * from "./factories/MethodIdFactory";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,10 @@
+export * from "./method/runtimeMethod";
+export * from "./module/decorator";
+export * from "./runtime/RuntimeModule";
+export * from "./runtime/RuntimeEnvironment";
+export * from "./runtime/Runtime";
+export * from "./state/InMemoryStateService";
+export * from "./state/decorator";
+export * from "./method/MethodParameterEncoder";
+export * from "./runtime/MethodIdResolver";
+export * from "./factories/MethodIdFactory";

package/dist/src/method/MethodParameterEncoder.d.ts

@@ -0,0 +1,22 @@
+import { Field, FlexibleProvable, ProvableExtended } from "o1js";
+import { ArgumentTypes } from "@proto-kit/common";
+import type { RuntimeModule } from "../runtime/RuntimeModule";
+export declare class MethodParameterEncoder {
+    private readonly types;
+    static fromMethod(target: RuntimeModule<unknown>, methodName: string): MethodParameterEncoder;
+    static fieldSize(type: ProvableExtended<unknown>): number | undefined;
+    private constructor();
+    decode(argsJSON: string[]): FlexibleProvable<unknown>[];
+    decodeFields(fields: Field[]): ArgumentTypes;
+    /**
+     * Variant of encode() for provable code that skips the unprovable
+     * json encoding
+     */
+    encodeAsFields(args: ArgumentTypes): import("o1js/dist/node/lib/provable/field").Field[];
+    encode(args: ArgumentTypes): {
+        argsFields: Field[];
+        argsJSON: string[];
+    };
+    get fieldSize(): number;
+}
+//# sourceMappingURL=MethodParameterEncoder.d.ts.map

package/dist/src/method/MethodParameterEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodParameterEncoder.d.ts","sourceRoot":"","sources":["../../../src/method/MethodParameterEncoder.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,gBAAgB,EAGhB,gBAAgB,EACjB,MAAM,MAAM,CAAC;AACd,OAAO,EACL,aAAa,EAKd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAgB9D,qBAAa,sBAAsB;IAuBb,OAAO,CAAC,QAAQ,CAAC,KAAK;WAtB5B,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,MAAM;WAiB7D,SAAS,CAAC,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS;IAK5E,OAAO;IAEA,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAC,EAAE;IAmBvD,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,aAAa;IAkBnD;;;OAGG;IACI,cAAc,CAAC,IAAI,EAAE,aAAa;IA2BlC,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG;QAClC,UAAU,EAAE,KAAK,EAAE,CAAC;QACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;IAqBD,IAAW,SAAS,IAAI,MAAM,CAI7B;CACF"}

package/dist/src/method/MethodParameterEncoder.js

@@ -0,0 +1,103 @@
+/* eslint-disable no-underscore-dangle,@typescript-eslint/consistent-type-assertions */
+import { Proof, Provable, } from "o1js";
+const errors = {
+    fieldLengthNotMatching: (expected, actual) => new Error(`Expected ${expected} field elements, got ${actual}`),
+    typeNotCompatible: (name, error) => new Error(`Cannot decode type ${name}, it has to be either a Struct, CircuitValue or built-in snarkyjs type.${error !== undefined ? `Caused by: ${error}` : ""}`),
+};
+export class MethodParameterEncoder {
+    static fromMethod(target, methodName) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const paramtypes = Reflect.getMetadata("design:paramtypes", target, methodName);
+        if (paramtypes === undefined) {
+            throw new Error(`Method with name ${methodName} doesn't exist on this module`);
+        }
+        return new MethodParameterEncoder(paramtypes);
+    }
+    static fieldSize(type) {
+        // as any, since we shouldn't be using this workaround in the first place
+        return type.prototype._fields?.length ?? type.sizeInFields?.();
+    }
+    constructor(types) {
+        Object.defineProperty(this, "types", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: types
+        });
+    }
+    decode(argsJSON) {
+        return this.types.map((type, index) => {
+            let value;
+            try {
+                value = type.fromJSON(JSON.parse(argsJSON[index]));
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    throw errors.typeNotCompatible(type.constructor.name, e.message);
+                }
+                throw errors.typeNotCompatible(type.constructor.name);
+            }
+            return value;
+        });
+    }
+    decodeFields(fields) {
+        if (fields.length < this.fieldSize) {
+            throw errors.fieldLengthNotMatching(this.fieldSize, fields.length);
+        }
+        let stack = fields.slice();
+        return this.types.map((type) => {
+            const numberFieldsNeeded = MethodParameterEncoder.fieldSize(type) ?? -1;
+            if (numberFieldsNeeded === -1) {
+                throw errors.typeNotCompatible(type.constructor.name);
+            }
+            const structFields = stack.slice(0, numberFieldsNeeded);
+            stack = stack.slice(numberFieldsNeeded);
+            return type.fromFields(structFields, []);
+        });
+    }
+    /**
+     * Variant of encode() for provable code that skips the unprovable
+     * json encoding
+     */
+    encodeAsFields(args) {
+        /**
+         * Use the type info obtained previously to convert
+         * the args passed to fields
+         */
+        return args.flatMap((argument, index) => {
+            if (argument instanceof Proof) {
+                const argumentType = this.types[index];
+                const publicOutputType = argumentType?.publicOutputType;
+                const publicInputType = argumentType?.publicInputType;
+                const inputFields = publicInputType?.toFields(argument.publicInput) ?? [];
+                const outputFields = publicOutputType?.toFields(argument.publicOutput) ?? [];
+                return [...inputFields, ...outputFields];
+            }
+            const argumentType = this.types[index];
+            return argumentType.toFields(argument);
+        });
+    }
+    encode(args) {
+        const argsFields = this.encodeAsFields(args);
+        let argsJSON = [];
+        Provable.asProver(() => {
+            argsJSON = args.map((argument, index) => {
+                if (argument instanceof Proof) {
+                    return JSON.stringify(argument.toJSON());
+                }
+                const argumentType = this.types[index];
+                return JSON.stringify(argumentType.toJSON(argument));
+            });
+        });
+        return {
+            argsFields,
+            argsJSON,
+        };
+    }
+    get fieldSize() {
+        return this.types
+            .map((type) => MethodParameterEncoder.fieldSize(type) ?? 0)
+            .reduce((a, b) => a + b, 0);
+    }
+}
+/* eslint-enable no-underscore-dangle,@typescript-eslint/consistent-type-assertions */

package/dist/src/method/runtimeMethod.d.ts

@@ -0,0 +1,26 @@
+import { StateTransition, MethodPublicOutput } from "@proto-kit/protocol";
+import { ArgumentTypes } from "@proto-kit/common";
+import type { RuntimeModule } from "../runtime/RuntimeModule.js";
+export declare function toStateTransitionsHash(stateTransitions: StateTransition<any>[]): import("o1js/dist/node/lib/provable/field.js").Field;
+export type WrappedMethod = (...args: ArgumentTypes) => MethodPublicOutput;
+export type AsyncWrappedMethod = (...args: ArgumentTypes) => Promise<MethodPublicOutput>;
+export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: ArgumentTypes) => Promise<any>, options: {
+    invocationType: RuntimeMethodInvocationType;
+}): AsyncWrappedMethod;
+export declare function combineMethodName(runtimeModuleName: string, methodName: string): string;
+export declare const runtimeMethodMetadataKey = "yab-method";
+export declare const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
+export declare const runtimeMethodTypeMetadataKey = "proto-kit-runtime-method-type";
+/**
+ * Checks the metadata of the provided runtime module and its method,
+ * to see if it has been decorated with @runtimeMethod()
+ *
+ * @param target - Runtime module to check
+ * @param propertyKey - Name of the method to check in the prior runtime module
+ * @returns - If the provided method name is a runtime method or not
+ */
+export declare function isRuntimeMethod(target: RuntimeModule<unknown>, propertyKey: string): boolean;
+export type RuntimeMethodInvocationType = "SIGNATURE" | "INCOMING_MESSAGE";
+export declare function runtimeMessage(): (target: RuntimeModule<unknown>, methodName: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+export declare function runtimeMethod(): (target: RuntimeModule<unknown>, methodName: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+//# sourceMappingURL=runtimeMethod.d.ts.map

package/dist/src/method/runtimeMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EAEf,kBAAkB,EAGnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAIL,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAqBjE,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,wDAczC;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,kBAAkB,CAAC;AAC3E,MAAM,MAAM,kBAAkB,GAAG,CAC/B,GAAG,IAAI,EAAE,aAAa,KACnB,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC,GAAG,CAAC,EACtD,OAAO,EAAE;IACP,cAAc,EAAE,2BAA2B,CAAC;CAC7C,GACA,kBAAkB,CAgFpB;AAED,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,MAAM,UAGnB;AAED,eAAO,MAAM,wBAAwB,eAAe,CAAC;AACrD,eAAO,MAAM,6BAA6B,8BAA8B,CAAC;AACzE,eAAO,MAAM,4BAA4B,kCAAkC,CAAC;AAE5E;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,MAAM,MAAM,2BAA2B,GAAG,WAAW,GAAG,kBAAkB,CAAC;AA4G3E,wBAAgB,cAAc,+HAI7B;AAED,wBAAgB,aAAa,+HAI5B"}

package/dist/src/method/runtimeMethod.js

@@ -0,0 +1,164 @@
+import { Bool, Field, Poseidon } from "o1js";
+import { container } from "tsyringe";
+import { ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext, StateTransitionReductionList, } from "@proto-kit/protocol";
+import { toProver, } from "@proto-kit/common";
+import { MethodParameterEncoder } from "./MethodParameterEncoder";
+const errors = {
+    runtimeNotProvided: (name) => new Error(`Runtime was not provided for module: ${name}`),
+    methodInputsNotProvided: () => new Error("Method execution inputs not provided, provide them via context.inputs"),
+    runtimeNameNotSet: () => new Error("Runtime name was not set"),
+    fieldNotConstant: (name) => new Error(`In-circuit field ${name} not a constant, this is likely a framework bug`),
+};
+export function toStateTransitionsHash(stateTransitions) {
+    const stateTransitionsHashList = new StateTransitionReductionList(ProvableStateTransition);
+    return stateTransitions
+        .map((stateTransition) => stateTransition.toProvable())
+        .reduce((allStateTransitionsHashList, stateTransition) => allStateTransitionsHashList.push(stateTransition), stateTransitionsHashList)
+        .toField();
+}
+export function toWrappedMethod(methodName, moduleMethod, options) {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+    const wrappedMethod = async (...args) => {
+        await Reflect.apply(moduleMethod, this, args);
+        const { result: { stateTransitions, status }, } = executionContext.current();
+        const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
+        const { name, runtime } = this;
+        if (name === undefined) {
+            throw errors.runtimeNameNotSet();
+        }
+        if (runtime === undefined) {
+            throw errors.runtimeNotProvided(name);
+        }
+        const { transaction, networkState } = executionContext.witnessInput();
+        const { methodIdResolver } = runtime;
+        // Assert that the given transaction has the correct methodId
+        const thisMethodId = Field(methodIdResolver.getMethodId(name, methodName));
+        if (!thisMethodId.isConstant()) {
+            throw errors.fieldNotConstant("methodId");
+        }
+        transaction.methodId.assertEquals(thisMethodId, "Runtimemethod called with wrong methodId on the transaction object");
+        /**
+         * Use the type info obtained previously to convert
+         * the args passed to fields
+         */
+        const { argsFields } = MethodParameterEncoder.fromMethod(this, methodName).encode(args);
+        // Assert that the argsHash that has been signed matches the given arguments
+        // We can use js-if here, because args are statically sized
+        // i.e. the result of the if-statement will be the same for all executions
+        // of this method
+        const argsHash = (args ?? []).length > 0 ? Poseidon.hash(argsFields) : Field(0);
+        transaction.argsHash.assertEquals(argsHash, "argsHash and therefore arguments of transaction and runtime call does not match");
+        const isMessage = Bool(options.invocationType === "INCOMING_MESSAGE");
+        transaction.assertTransactionType(Bool(isMessage));
+        const transactionHash = transaction.hash();
+        const networkStateHash = networkState.hash();
+        return new MethodPublicOutput({
+            stateTransitionsHash,
+            status,
+            transactionHash,
+            networkStateHash,
+            isMessage,
+        });
+    };
+    Object.defineProperty(wrappedMethod, "name", {
+        value: `wrapped_${methodName}`,
+        writable: false,
+    });
+    return wrappedMethod;
+}
+export function combineMethodName(runtimeModuleName, methodName) {
+    return `${runtimeModuleName}.${methodName}`;
+}
+export const runtimeMethodMetadataKey = "yab-method";
+export const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
+export const runtimeMethodTypeMetadataKey = "proto-kit-runtime-method-type";
+/**
+ * Checks the metadata of the provided runtime module and its method,
+ * to see if it has been decorated with @runtimeMethod()
+ *
+ * @param target - Runtime module to check
+ * @param propertyKey - Name of the method to check in the prior runtime module
+ * @returns - If the provided method name is a runtime method or not
+ */
+export function isRuntimeMethod(target, propertyKey) {
+    return Boolean(Reflect.getMetadata(runtimeMethodMetadataKey, target, propertyKey));
+}
+function runtimeMethodInternal(options) {
+    return (target, methodName, descriptor) => {
+        const executionContext = container.resolve(RuntimeMethodExecutionContext);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        let data = Reflect.getMetadata(runtimeMethodNamesMetadataKey, target);
+        if (data !== undefined) {
+            data.push(methodName);
+        }
+        else {
+            data = [methodName];
+        }
+        Reflect.defineMetadata(runtimeMethodNamesMetadataKey, data, target);
+        Reflect.defineMetadata(runtimeMethodMetadataKey, true, target, methodName);
+        Reflect.defineMetadata(runtimeMethodTypeMetadataKey, options.invocationType, target, methodName);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const simulatedMethod = descriptor.value;
+        descriptor.value = async function value(...args) {
+            const constructorName = this.name;
+            /**
+             * If its a top level method call, wrap it into a wrapped method,
+             * since it'll be turned into a real/mock prover in provableMethod().
+             *
+             * Otherwise provableMethod() will just call the originalMethod provided
+             * if method is not called at the top level.
+             */
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
+                methodName,
+                simulatedMethod,
+                options,
+            ]);
+            /**
+             * Before the prover runs, make sure it is operating on the correct
+             * RuntimeMethodExecutionContext state, meaning it enters and exits
+             * the context properly.
+             */
+            async function prover() {
+                executionContext.beforeMethod(constructorName, methodName, args);
+                const innerProver = toProver(combineMethodName(constructorName, methodName), 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                simulatedWrappedMethod, false, ...args).bind(this);
+                let result;
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    result = await Reflect.apply(innerProver, this, args);
+                }
+                finally {
+                    executionContext.afterMethod();
+                }
+                return result;
+            }
+            executionContext.beforeMethod(constructorName, methodName, args);
+            if (executionContext.isTopLevel) {
+                if (!this.runtime) {
+                    throw errors.runtimeNotProvided(constructorName);
+                }
+                executionContext.setProver(prover.bind(this.runtime.zkProgrammable));
+            }
+            let result;
+            try {
+                result = Reflect.apply(simulatedMethod, this, args);
+            }
+            finally {
+                executionContext.afterMethod();
+            }
+            return result;
+        };
+    };
+}
+export function runtimeMessage() {
+    return runtimeMethodInternal({
+        invocationType: "INCOMING_MESSAGE",
+    });
+}
+export function runtimeMethod() {
+    return runtimeMethodInternal({
+        invocationType: "SIGNATURE",
+    });
+}

package/dist/src/module/decorator.d.ts

@@ -0,0 +1,8 @@
+import { StaticConfigurableModule, TypedClass } from "@proto-kit/common";
+import { RuntimeModule } from "../runtime/RuntimeModule.js";
+/**
+ * Marks the decorated class as a runtime module, while also
+ * making it injectable with our dependency injection solution.
+ */
+export declare function runtimeModule(): (target: StaticConfigurableModule<unknown> & TypedClass<RuntimeModule<unknown>>) => void;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/src/module/decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../../src/module/decorator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D;;;GAGG;AACH,wBAAgB,aAAa,aAMjB,yBAAyB,OAAO,CAAC,GACvC,WAAW,cAAc,OAAO,CAAC,CAAC,UAIvC"}

package/dist/src/module/decorator.js

@@ -0,0 +1,15 @@
+import { injectable } from "tsyringe";
+/**
+ * Marks the decorated class as a runtime module, while also
+ * making it injectable with our dependency injection solution.
+ */
+export function runtimeModule() {
+    return (
+    /**
+     * Check if the target class extends RuntimeModule, while
+     * also providing static config presets
+     */
+    target) => {
+        injectable()(target);
+    };
+}

package/dist/src/runtime/MethodIdResolver.d.ts

@@ -0,0 +1,20 @@
+import { RuntimeMethodIdMapping } from "@proto-kit/protocol";
+import type { Runtime, RuntimeModulesRecord } from "./Runtime";
+/**
+ * Please see `getMethodId` to learn more about
+ * methodId encoding
+ */
+export declare class MethodIdResolver {
+    private readonly runtime;
+    private readonly dictionary;
+    constructor(runtime: Runtime<RuntimeModulesRecord>);
+    /**
+     * The purpose of this method is to provide a dictionary where
+     * we can look up properties like methodId and invocationType
+     * for each runtimeMethod using their module name and method name
+     */
+    methodIdMap(): RuntimeMethodIdMapping;
+    getMethodNameFromId(methodId: bigint): [string, string] | undefined;
+    getMethodId(moduleName: string, methodName: string): bigint;
+}
+//# sourceMappingURL=MethodIdResolver.d.ts.map

package/dist/src/runtime/MethodIdResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodIdResolver.d.ts","sourceRoot":"","sources":["../../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAS5E,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAE/D;;;GAGG;AACH,qBACa,gBAAgB;IAMN,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAEpB;gBAG+B,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAkB5E;;;;OAIG;IACI,WAAW,IAAI,sBAAsB;IAuCrC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAcnE,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAQnE"}

package/dist/src/runtime/MethodIdResolver.js

@@ -0,0 +1,100 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { filterNonUndefined } from "@proto-kit/common";
+import { stringToField } from "@proto-kit/protocol";
+import { Poseidon } from "o1js";
+import { inject, injectable } from "tsyringe";
+import { runtimeMethodTypeMetadataKey, } from "../method/runtimeMethod";
+/**
+ * Please see `getMethodId` to learn more about
+ * methodId encoding
+ */
+export let MethodIdResolver = class MethodIdResolver {
+    constructor(runtime) {
+        Object.defineProperty(this, "runtime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: runtime
+        });
+        Object.defineProperty(this, "dictionary", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        this.dictionary = runtime.runtimeModuleNames.reduce((dict, moduleName) => {
+            this.runtime.assertIsValidModuleName(moduleName);
+            runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
+                dict[this.getMethodId(moduleName, methodName).toString()] = {
+                    moduleName,
+                    methodName,
+                };
+            });
+            return dict;
+        }, {});
+    }
+    /**
+     * The purpose of this method is to provide a dictionary where
+     * we can look up properties like methodId and invocationType
+     * for each runtimeMethod using their module name and method name
+     */
+    methodIdMap() {
+        const methodIdResolver = this.runtime.dependencyContainer.resolve("MethodIdResolver");
+        const rawMappings = this.runtime.moduleNames.flatMap((moduleName) => {
+            const module = this.runtime.resolve(moduleName);
+            return module.runtimeMethodNames.map((method) => {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const type = Reflect.getMetadata(runtimeMethodTypeMetadataKey, module, method);
+                if (type !== undefined) {
+                    return {
+                        name: `${moduleName}.${method}`,
+                        methodId: methodIdResolver.getMethodId(moduleName, method),
+                        type,
+                    };
+                }
+                return undefined;
+            });
+        });
+        return rawMappings
+            .filter(filterNonUndefined)
+            .reduce((acc, entry) => {
+            acc[entry.name] = {
+                methodId: entry.methodId,
+                type: entry.type,
+            };
+            return acc;
+        }, {});
+    }
+    getMethodNameFromId(methodId) {
+        const methodPath = this.dictionary[methodId.toString()];
+        if (methodPath === undefined) {
+            return undefined;
+        }
+        const { moduleName, methodName } = methodPath;
+        this.runtime.assertIsValidModuleName(moduleName);
+        return [moduleName, methodName];
+    }
+    getMethodId(moduleName, methodName) {
+        this.runtime.assertIsValidModuleName(moduleName);
+        return Poseidon.hash([
+            stringToField(moduleName),
+            stringToField(methodName),
+        ]).toBigInt();
+    }
+};
+MethodIdResolver = __decorate([
+    injectable(),
+    __param(0, inject("Runtime")),
+    __metadata("design:paramtypes", [Function])
+], MethodIdResolver);