@proto-kit/module 0.1.1-develop.457 → 0.1.1-develop.651

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export * from "./runtime/RuntimeEnvironment";
 export * from "./runtime/Runtime";
 export * from "./state/InMemoryStateService";
 export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
+export * from "./method/MethodParameterEncoder";
 export * from "./runtime/MethodIdResolver";
 export * from "./factories/MethodIdFactory";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -5,6 +5,6 @@ export * from "./runtime/RuntimeEnvironment";
 export * from "./runtime/Runtime";
 export * from "./state/InMemoryStateService";
 export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
+export * from "./method/MethodParameterEncoder";
 export * from "./runtime/MethodIdResolver";
 export * from "./factories/MethodIdFactory";

package/dist/method/MethodParameterEncoder.d.ts

@@ -0,0 +1,17 @@
+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;
+    encode(args: ArgumentTypes): {
+        argsFields: Field[];
+        argsJSON: string[];
+    };
+    get fieldSize(): number;
+}
+//# sourceMappingURL=MethodParameterEncoder.d.ts.map

package/dist/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;IAsBvD,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,aAAa;IAkB5C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG;QAClC,UAAU,EAAE,KAAK,EAAE,CAAC;QACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;IA4CD,IAAW,SAAS,IAAI,MAAM,CAI7B;CACF"}

package/dist/method/MethodParameterEncoder.js

@@ -0,0 +1,93 @@
+/* eslint-disable no-underscore-dangle */
+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) {
+        this.types = types;
+    }
+    decode(argsJSON) {
+        return this.types.map((type, index) => {
+            // eslint-disable-next-line @typescript-eslint/init-declarations
+            let value;
+            try {
+                // eslint-disable-next-line max-len
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                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, []);
+        });
+    }
+    encode(args) {
+        /**
+         * Use the type info obtained previously to convert
+         * the args passed to fields
+         */
+        const argsFields = 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);
+        });
+        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);
+    }
+}

package/dist/method/runtimeMethod.d.ts

@@ -3,10 +3,13 @@ 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/field.js").Field;
 export type WrappedMethod = (...args: ArgumentTypes) => MethodPublicOutput;
-export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: ArgumentTypes) => unknown, methodArguments: ArgumentTypes): WrappedMethod;
+export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: ArgumentTypes) => unknown, options: {
+    invocationType: RuntimeMethodInvocationType;
+}): WrappedMethod;
 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()
@@ -16,5 +19,7 @@ export declare const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods"
  * @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: PropertyDescriptor) => void;
 export declare function runtimeMethod(): (target: RuntimeModule<unknown>, methodName: string, descriptor: PropertyDescriptor) => void;
 //# sourceMappingURL=runtimeMethod.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AASA,OAAO,EACL,eAAe,EAGf,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAOL,aAAa,EAGd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAoBjE,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,+CAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,kBAAkB,CAAC;AAE3E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,OAAO,EACjD,eAAe,EAAE,aAAa,iBAqG/B;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;AAEzE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,wBAAgB,aAAa,aAEjB,cAAc,OAAO,CAAC,cAClB,MAAM,cACN,kBAAkB,UAwFjC"}
+{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EAEf,kBAAkB,EAKnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAOL,aAAa,EAGd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAsBjE,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,+CAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,kBAAkB,CAAC;AAE3E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,KAAK,OAAO,EACjD,OAAO,EAAE;IACP,cAAc,EAAE,2BAA2B,CAAC;CAC7C,iBAiFF;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;AAyG3E,wBAAgB,cAAc,iGAI7B;AAED,wBAAgB,aAAa,iGAI5B"}

package/dist/method/runtimeMethod.js

@@ -1,8 +1,9 @@
 /* eslint-disable max-statements */
-import { Field, Poseidon, Proof, } from "o1js";
+import { Bool, Field, Poseidon } from "o1js";
 import { container } from "tsyringe";
-import { DefaultProvableHashList, ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext, } from "@proto-kit/protocol";
+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"),
@@ -12,21 +13,19 @@ const errors = {
 export function toStateTransitionsHash(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 stateTransitions) {
-    const stateTransitionsHashList = new DefaultProvableHashList(ProvableStateTransition);
+    const stateTransitionsHashList = new StateTransitionReductionList(ProvableStateTransition);
     return stateTransitions
         .map((stateTransition) => stateTransition.toProvable())
         .reduce((allStateTransitionsHashList, stateTransition) => allStateTransitionsHashList.push(stateTransition), stateTransitionsHashList)
         .toField();
 }
-export function toWrappedMethod(methodName, moduleMethod, methodArguments) {
+export function toWrappedMethod(methodName, moduleMethod, options) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     const wrappedMethod = (...args) => {
         Reflect.apply(moduleMethod, this, args);
-        const { result: { stateTransitions, status }, input, } = executionContext.current();
+        const { result: { stateTransitions, status }, } = executionContext.current();
         const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
-        if (input === undefined) {
-            throw errors.methodInputsNotProvided();
-        }
+        const input = this.getInputs();
         const { name, runtime } = this;
         if (name === undefined) {
             throw errors.runtimeNameNotSet();
@@ -34,47 +33,35 @@ export function toWrappedMethod(methodName, moduleMethod, methodArguments) {
         if (runtime === undefined) {
             throw errors.runtimeNotProvided(name);
         }
-        // Assert that the given transaction has the correct methodId
+        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");
         }
-        input.transaction.methodId.assertEquals(thisMethodId, "Runtimemethod called with wrong methodId on the transaction object");
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const parameterTypes = Reflect.getMetadata("design:paramtypes", this, methodName);
+        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 = args.flatMap((argument, index) => {
-            if (argument instanceof Proof) {
-                // eslint-disable-next-line max-len
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const argumentType = parameterTypes[index];
-                const publicOutputType = argumentType?.publicOutputType;
-                const publicInputType = argumentType?.publicInputType;
-                const inputFields = publicInputType?.toFields(argument.publicInput) ?? [];
-                const outputFields = publicOutputType?.toFields(argument.publicOutput) ?? [];
-                return [...inputFields, ...outputFields];
-            }
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            const argumentType = parameterTypes[index];
-            return argumentType.toFields(argument);
-        });
+        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 methodArguments is statically sizes
+        // 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 = methodArguments.length > 0 ? Poseidon.hash(argsFields) : Field(0);
-        input.transaction.argsHash.assertEquals(argsHash, "argsHash and therefore arguments of transaction and runtime call does not match");
-        const transactionHash = input.transaction.hash();
-        const networkStateHash = input.networkState.hash();
+        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", {
@@ -88,6 +75,7 @@ export function combineMethodName(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()
@@ -99,7 +87,7 @@ export const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
 export function isRuntimeMethod(target, propertyKey) {
     return Boolean(Reflect.getMetadata(runtimeMethodMetadataKey, target, propertyKey));
 }
-export function runtimeMethod() {
+function runtimeMethodInternal(options) {
     return (target, methodName, descriptor) => {
         const executionContext = container.resolve(RuntimeMethodExecutionContext);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -112,10 +100,11 @@ export function runtimeMethod() {
         }
         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 = function value(...args) {
-            const constructorName = this.constructor.name;
+            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().
@@ -126,7 +115,7 @@ export function runtimeMethod() {
             const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
                 methodName,
                 simulatedMethod,
-                args,
+                options,
             ]);
             /**
              * Before the prover runs, make sure it is operating on the correct
@@ -167,3 +156,13 @@ export function runtimeMethod() {
         };
     };
 }
+export function runtimeMessage() {
+    return runtimeMethodInternal({
+        invocationType: "INCOMING_MESSAGE",
+    });
+}
+export function runtimeMethod() {
+    return runtimeMethodInternal({
+        invocationType: "SIGNATURE",
+    });
+}

package/dist/runtime/MethodIdResolver.d.ts

@@ -1,3 +1,4 @@
+import { RuntimeMethodIdMapping } from "@proto-kit/protocol";
 import type { Runtime, RuntimeModulesRecord } from "./Runtime";
 /**
  * Please see `getMethodId` to learn more about
@@ -7,6 +8,12 @@ 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;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"MethodIdResolver.d.ts","sourceRoot":"","sources":["../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"AAIA,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;IAoBrE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAiBnE,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAWnE"}
+{"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;IAsCrC,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/runtime/MethodIdResolver.js

@@ -10,9 +10,11 @@ var __metadata = (this && this.__metadata) || function (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
@@ -21,9 +23,8 @@ let MethodIdResolver = class MethodIdResolver {
     constructor(runtime) {
         this.runtime = runtime;
         this.dictionary = {};
-        const { modules } = runtime.definition;
         this.dictionary = runtime.runtimeModuleNames.reduce((dict, moduleName) => {
-            this.runtime.assertIsValidModuleName(modules, moduleName);
+            this.runtime.assertIsValidModuleName(moduleName);
             runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
                 dict[this.getMethodId(moduleName, methodName).toString()] = {
                     moduleName,
@@ -33,17 +34,48 @@ let MethodIdResolver = class MethodIdResolver {
             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) => {
+                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(this.runtime.definition.modules, moduleName);
+        this.runtime.assertIsValidModuleName(moduleName);
         return [moduleName, methodName];
     }
     getMethodId(moduleName, methodName) {
-        this.runtime.assertIsValidModuleName(this.runtime.definition.modules, moduleName);
+        this.runtime.assertIsValidModuleName(moduleName);
         return Poseidon.hash([
             stringToField(moduleName),
             stringToField(methodName),

package/dist/runtime/Runtime.d.ts

@@ -5,6 +5,7 @@ import { MethodPublicOutput, StateServiceProvider, StateService } from "@proto-k
 import { RuntimeModule } from "./RuntimeModule";
 import { MethodIdResolver } from "./MethodIdResolver";
 import { RuntimeEnvironment } from "./RuntimeEnvironment";
+export declare function getAllPropertyNames(obj: any): (string | symbol)[];
 /**
  * Record of modules accepted by the Runtime module container.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/Runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAc,MAAM,UAAU,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,EACd,cAAc,EAEd,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACb,MAAM,qBAAqB,CAAC;AAU7B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAC9C,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CACnC,CAAC;AAOF;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,oBAAoB;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,qBAAa,qBAAqB,CAChC,OAAO,SAAS,oBAAoB,CACpC,SAAQ,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;IAE3B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;gBAAzB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;IAInD,IAAW,QAAQ,iCAElB;IAEM,gBAAgB,IAAI,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;CAgHzE;AAED;;;GAGG;AACH,qBACa,OAAO,CAAC,OAAO,SAAS,oBAAoB,CACvD,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,kBAAkB;WAEf,IAAI,CAAC,OAAO,SAAS,oBAAoB,EACrD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACrC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IASxB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;IAEpD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAEvC,cAAc,EAAE,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;IAErE;;;;OAIG;gBACgB,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAQlD,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;IAM5D,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAItD;IAED,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED,IAAW,gBAAgB,IAAI,gBAAgB,CAE9C;IAED;;OAEG;IACH,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED;;;OAGG;IACI,aAAa,CAClB,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS;IAuBhD;;;;;;OAMG;IACI,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAQ9D;;OAEG;IACH,IAAW,kBAAkB,aAE5B;CACF"}
+{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/Runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAc,MAAM,UAAU,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACb,MAAM,qBAAqB,CAAC;AAW7B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,uBAW3C;AAED;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAC9C,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CACnC,CAAC;AAOF;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,oBAAoB;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,qBAAa,qBAAqB,CAChC,OAAO,SAAS,oBAAoB,CACpC,SAAQ,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;IAE3B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;gBAAzB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;IAInD,IAAW,QAAQ,iCAElB;IAEM,gBAAgB,IAAI,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;CAwHzE;AAED;;;GAGG;AACH,qBACa,OAAO,CAAC,OAAO,SAAS,oBAAoB,CACvD,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,kBAAkB;WAEf,IAAI,CAAC,OAAO,SAAS,oBAAoB,EACrD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACrC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IASxB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;IAEpD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAEvC,cAAc,EAAE,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;IAErE;;;;OAIG;gBACgB,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAQlD,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;IAM5D,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAItD;IAED,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED,IAAW,gBAAgB,IAAI,gBAAgB,CAE9C;IAED;;OAEG;IACH,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED;;;OAGG;IACI,aAAa,CAClB,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS;IAuBhD;;;;;;OAMG;IACI,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAQ9D;;OAEG;IACH,IAAW,kBAAkB,aAE5B;CACF"}

package/dist/runtime/Runtime.js

@@ -14,8 +14,20 @@ import { Experimental } from "o1js";
 import { injectable } from "tsyringe";
 import { ModuleContainer, ZkProgrammable, } from "@proto-kit/common";
 import { MethodPublicOutput, } from "@proto-kit/protocol";
-import { combineMethodName, isRuntimeMethod, toWrappedMethod, } from "../method/runtimeMethod";
+import { combineMethodName, isRuntimeMethod, runtimeMethodTypeMetadataKey, toWrappedMethod, } from "../method/runtimeMethod";
 import { MethodIdFactory } from "../factories/MethodIdFactory";
+export function getAllPropertyNames(obj) {
+    let keys = [];
+    // if primitive (primitives still have keys) skip the first iteration
+    if (!(obj instanceof Object)) {
+        obj = Object.getPrototypeOf(obj);
+    }
+    while (obj) {
+        keys = keys.concat(Reflect.ownKeys(obj));
+        obj = Object.getPrototypeOf(obj);
+    }
+    return keys;
+}
 const errors = {
     methodNotFound: (methodKey) => new Error(`Unable to find method with id ${methodKey}`),
 };
@@ -47,12 +59,13 @@ export class RuntimeZkProgrammable extends ZkProgrammable {
             // eslint-disable-next-line max-len
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             const modulePrototype = Object.getPrototypeOf(runtimeModule);
-            const modulePrototypeMethods = Object.getOwnPropertyNames(modulePrototype);
+            const modulePrototypeMethods = getAllPropertyNames(runtimeModule).map((method) => method.toString());
             const moduleMethods = modulePrototypeMethods.reduce((allModuleMethods, methodName) => {
                 if (isRuntimeMethod(runtimeModule, methodName)) {
                     const combinedMethodName = combineMethodName(runtimeModuleName, methodName);
                     const method = modulePrototype[methodName];
-                    const wrappedMethod = Reflect.apply(toWrappedMethod, runtimeModule, [methodName, method]);
+                    const invocationType = Reflect.getMetadata(runtimeMethodTypeMetadataKey, runtimeModule, methodName);
+                    const wrappedMethod = Reflect.apply(toWrappedMethod, runtimeModule, [methodName, method, { invocationType }]);
                     // eslint-disable-next-line no-warning-comments
                     // TODO: find out how to import the Tuple type
                     const privateInputs = Reflect.getMetadata("design:paramtypes", runtimeModule, methodName);
@@ -86,6 +99,7 @@ export class RuntimeZkProgrammable extends ZkProgrammable {
         return {
             compile: program.compile.bind(program),
             verify: program.verify.bind(program),
+            analyzeMethods: program.analyzeMethods.bind(program),
             Proof: SelfProof,
             methods,
         };
@@ -147,7 +161,7 @@ let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
             return undefined;
         }
         const [moduleName, methodName] = methodDescriptor;
-        this.assertIsValidModuleName(this.definition.modules, moduleName);
+        this.assertIsValidModuleName(moduleName);
         const module = this.resolve(moduleName);
         // eslint-disable-next-line max-len
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions,@typescript-eslint/no-unsafe-member-access

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,EAGlB,0BAA0B,EAE3B,MAAM,qBAAqB,CAAC;AAS7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO1D;;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,8 +9,9 @@ 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 { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
+import { Provable } from "o1js";
 const errors = {
     inputDataNotSet: () => new Error("Input data for runtime execution not set"),
 };
@@ -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;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@proto-kit/module",
   "license": "MIT",
   "private": false,
-  "version": "0.1.1-develop.457+467a974",
+  "version": "0.1.1-develop.651+7591cb6",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -31,5 +31,5 @@
     "o1js": "0.13.1",
     "tsyringe": "^4.7.0"
   },
-  "gitHead": "467a974c8dddb9f57ecf37caf34d3e1e5eb33f2a"
+  "gitHead": "7591cb6bdf58a6cd525a10902c25bc292efcfc6b"
 }

package/src/index.ts

@@ -5,6 +5,6 @@ export * from "./runtime/RuntimeEnvironment";
 export * from "./runtime/Runtime";
 export * from "./state/InMemoryStateService";
 export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
+export * from "./method/MethodParameterEncoder";
 export * from "./runtime/MethodIdResolver";
 export * from "./factories/MethodIdFactory";

package/src/method/MethodParameterEncoder.ts

@@ -0,0 +1,150 @@
+/* eslint-disable no-underscore-dangle */
+import {
+  Field,
+  FlexibleProvable,
+  Proof,
+  Provable,
+  ProvableExtended,
+} from "o1js";
+import {
+  ArgumentTypes,
+  ProofTypes,
+  ToFieldable,
+  ToFieldableStatic,
+  ToJSONableStatic,
+} from "@proto-kit/common";
+
+import type { RuntimeModule } from "../runtime/RuntimeModule";
+
+const errors = {
+  fieldLengthNotMatching: (expected: number, actual: number) =>
+    new Error(`Expected ${expected} field elements, got ${actual}`),
+
+  typeNotCompatible: (name: string, error?: string) =>
+    new Error(
+      `Cannot decode type ${name}, it has to be either a Struct, CircuitValue or built-in snarkyjs type.${
+        error !== undefined ? `Caused by: ${error}` : ""
+      }`
+    ),
+};
+
+type ArgsArray = ProvableExtended<unknown>[];
+
+export class MethodParameterEncoder {
+  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const paramtypes: ArgsArray = 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);
+  }
+
+  public static fieldSize(type: ProvableExtended<unknown>): number | undefined {
+    // as any, since we shouldn't be using this workaround in the first place
+    return (type as any).prototype._fields?.length ?? type.sizeInFields?.();
+  }
+
+  private constructor(private readonly types: ArgsArray) {}
+
+  public decode(argsJSON: string[]): FlexibleProvable<unknown>[] {
+    return this.types.map((type, index) => {
+      // eslint-disable-next-line @typescript-eslint/init-declarations
+      let value: FlexibleProvable<unknown>;
+
+      try {
+        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        value = type.fromJSON(
+          JSON.parse(argsJSON[index])
+        ) as FlexibleProvable<unknown>;
+      } catch (e: unknown) {
+        if (e instanceof Error) {
+          throw errors.typeNotCompatible(type.constructor.name, e.message);
+        }
+        throw errors.typeNotCompatible(type.constructor.name);
+      }
+
+      return value;
+    });
+  }
+
+  public decodeFields(fields: Field[]): ArgumentTypes {
+    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, []) as ToFieldable;
+    });
+  }
+
+  public encode(args: ArgumentTypes): {
+    argsFields: Field[];
+    argsJSON: string[];
+  } {
+    /**
+     * Use the type info obtained previously to convert
+     * the args passed to fields
+     */
+    const argsFields = args.flatMap((argument, index) => {
+      if (argument instanceof Proof) {
+        const argumentType = this.types[index] as ProofTypes;
+
+        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] as ToFieldableStatic;
+      return argumentType.toFields(argument);
+    });
+
+    let argsJSON: string[] = [];
+    Provable.asProver(() => {
+      argsJSON = args.map((argument, index) => {
+        if (argument instanceof Proof) {
+          return JSON.stringify(argument.toJSON());
+        }
+
+        const argumentType = this.types[index] as ToJSONableStatic;
+        return JSON.stringify(argumentType.toJSON(argument));
+      });
+    });
+
+    return {
+      argsFields,
+      argsJSON,
+    };
+  }
+
+  public get fieldSize(): number {
+    return this.types
+      .map((type) => MethodParameterEncoder.fieldSize(type) ?? 0)
+      .reduce((a, b) => a + b, 0);
+  }
+}

package/src/method/runtimeMethod.ts

@@ -1,18 +1,14 @@
 /* eslint-disable max-statements */
-import {
-  Field,
-  FlexibleProvable,
-  Poseidon,
-  Proof,
-  ProvableExtended,
-} from "o1js";
+import { Bool, Field, Poseidon } from "o1js";
 import { container } from "tsyringe";
 import {
   StateTransition,
-  DefaultProvableHashList,
   ProvableStateTransition,
   MethodPublicOutput,
   RuntimeMethodExecutionContext,
+  RuntimeMethodExecutionDataStruct,
+  SignedTransaction,
+  StateTransitionReductionList,
 } from "@proto-kit/protocol";
 import {
   DecoratedMethod,
@@ -28,6 +24,8 @@ import {
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 import { MethodIdResolver } from "../runtime/MethodIdResolver";
+import { state } from "../state/decorator.js";
+import { MethodParameterEncoder } from "./MethodParameterEncoder";
 
 const errors = {
   runtimeNotProvided: (name: string) =>
@@ -50,7 +48,7 @@ export function toStateTransitionsHash(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   stateTransitions: StateTransition<any>[]
 ) {
-  const stateTransitionsHashList = new DefaultProvableHashList(
+  const stateTransitionsHashList = new StateTransitionReductionList(
     ProvableStateTransition
   );
 
@@ -71,7 +69,9 @@ export function toWrappedMethod(
   this: RuntimeModule<unknown>,
   methodName: string,
   moduleMethod: (...args: ArgumentTypes) => unknown,
-  methodArguments: ArgumentTypes
+  options: {
+    invocationType: RuntimeMethodInvocationType;
+  }
 ) {
   const executionContext = container.resolve<RuntimeMethodExecutionContext>(
     RuntimeMethodExecutionContext
@@ -81,14 +81,11 @@ export function toWrappedMethod(
     Reflect.apply(moduleMethod, this, args);
     const {
       result: { stateTransitions, status },
-      input,
     } = executionContext.current();
 
     const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
 
-    if (input === undefined) {
-      throw errors.methodInputsNotProvided();
-    }
+    const input = this.getInputs();
 
     const { name, runtime } = this;
 
@@ -99,70 +96,53 @@ export function toWrappedMethod(
       throw errors.runtimeNotProvided(name);
     }
 
-    // Assert that the given transaction has the correct methodId
+    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");
     }
 
-    input.transaction.methodId.assertEquals(
+    transaction.methodId.assertEquals(
       thisMethodId,
       "Runtimemethod called with wrong methodId on the transaction object"
     );
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const parameterTypes: ProofTypes[] | ToFieldableStatic[] =
-      Reflect.getMetadata("design:paramtypes", this, methodName);
-
     /**
      * Use the type info obtained previously to convert
      * the args passed to fields
      */
-    const argsFields = args.flatMap((argument, index) => {
-      if (argument instanceof Proof) {
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const argumentType = parameterTypes[index] as ProofTypes;
-
-        const publicOutputType = argumentType?.publicOutputType;
-
-        const publicInputType = argumentType?.publicInputType;
-
-        const inputFields =
-          publicInputType?.toFields(argument.publicInput) ?? [];
-
-        const outputFields =
-          publicOutputType?.toFields(argument.publicOutput) ?? [];
-
-        return [...inputFields, ...outputFields];
-      }
-
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const argumentType = parameterTypes[index] as ToFieldableStatic;
-      return argumentType.toFields(argument);
-    });
+    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 methodArguments is statically sizes
+    // 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 =
-      methodArguments.length > 0 ? Poseidon.hash(argsFields) : Field(0);
+      (args ?? []).length > 0 ? Poseidon.hash(argsFields) : Field(0);
 
-    input.transaction.argsHash.assertEquals(
+    transaction.argsHash.assertEquals(
       argsHash,
       "argsHash and therefore arguments of transaction and runtime call does not match"
     );
 
-    const transactionHash = input.transaction.hash();
-    const networkStateHash = input.networkState.hash();
+    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,
     });
   };
 
@@ -183,6 +163,7 @@ export function combineMethodName(
 
 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,
@@ -201,7 +182,11 @@ export function isRuntimeMethod(
   );
 }
 
-export function runtimeMethod() {
+export type RuntimeMethodInvocationType = "SIGNATURE" | "INCOMING_MESSAGE";
+
+function runtimeMethodInternal(options: {
+  invocationType: RuntimeMethodInvocationType;
+}) {
   return (
     target: RuntimeModule<unknown>,
     methodName: string,
@@ -225,6 +210,13 @@ export function runtimeMethod() {
 
     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 as DecoratedMethod;
 
@@ -232,7 +224,7 @@ export function runtimeMethod() {
       this: RuntimeModule<unknown>,
       ...args: ArgumentTypes
     ) {
-      const constructorName = this.constructor.name;
+      const constructorName = this.name!;
 
       /**
        * If its a top level method call, wrap it into a wrapped method,
@@ -244,7 +236,7 @@ export function runtimeMethod() {
       const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
         methodName,
         simulatedMethod,
-        args,
+        options,
       ]);
 
       /**
@@ -294,3 +286,15 @@ export function runtimeMethod() {
     };
   };
 }
+
+export function runtimeMessage() {
+  return runtimeMethodInternal({
+    invocationType: "INCOMING_MESSAGE",
+  });
+}
+
+export function runtimeMethod() {
+  return runtimeMethodInternal({
+    invocationType: "SIGNATURE",
+  });
+}

package/src/runtime/MethodIdResolver.ts

@@ -1,7 +1,13 @@
-import { stringToField } from "@proto-kit/protocol";
+import { filterNonUndefined } from "@proto-kit/common";
+import { stringToField, RuntimeMethodIdMapping } from "@proto-kit/protocol";
 import { Poseidon } from "o1js";
 import { inject, injectable } from "tsyringe";
 
+import {
+  RuntimeMethodInvocationType,
+  runtimeMethodTypeMetadataKey,
+} from "../method/runtimeMethod";
+
 import type { Runtime, RuntimeModulesRecord } from "./Runtime";
 
 /**
@@ -17,12 +23,10 @@ export class MethodIdResolver {
   public constructor(
     @inject("Runtime") private readonly runtime: Runtime<RuntimeModulesRecord>
   ) {
-    const { modules } = runtime.definition;
-
     this.dictionary = runtime.runtimeModuleNames.reduce<
       Record<string, { moduleName: string; methodName: string }>
     >((dict, moduleName) => {
-      this.runtime.assertIsValidModuleName(modules, moduleName);
+      this.runtime.assertIsValidModuleName(moduleName);
 
       runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
         dict[this.getMethodId(moduleName, methodName).toString()] = {
@@ -35,6 +39,49 @@ export class MethodIdResolver {
     }, {});
   }
 
+  /**
+   * 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
+   */
+  public methodIdMap(): RuntimeMethodIdMapping {
+    const methodIdResolver =
+      this.runtime.dependencyContainer.resolve<MethodIdResolver>(
+        "MethodIdResolver"
+      );
+
+    const rawMappings = this.runtime.moduleNames.flatMap((moduleName) => {
+      const module = this.runtime.resolve(moduleName);
+      return module.runtimeMethodNames.map((method) => {
+        const type = Reflect.getMetadata(
+          runtimeMethodTypeMetadataKey,
+          module,
+          method
+        ) as RuntimeMethodInvocationType | undefined;
+
+        if (type !== undefined) {
+          return {
+            name: `${moduleName}.${method}`,
+            methodId: methodIdResolver.getMethodId(moduleName, method),
+            type,
+          } as const;
+        }
+
+        return undefined;
+      });
+    });
+
+    return rawMappings
+      .filter(filterNonUndefined)
+      .reduce<RuntimeMethodIdMapping>((acc, entry) => {
+        acc[entry.name] = {
+          methodId: entry.methodId,
+          type: entry.type,
+        };
+        return acc;
+      }, {});
+  }
+
   public getMethodNameFromId(methodId: bigint): [string, string] | undefined {
     const methodPath = this.dictionary[methodId.toString()];
 
@@ -44,19 +91,13 @@ export class MethodIdResolver {
 
     const { moduleName, methodName } = methodPath;
 
-    this.runtime.assertIsValidModuleName(
-      this.runtime.definition.modules,
-      moduleName
-    );
+    this.runtime.assertIsValidModuleName(moduleName);
 
     return [moduleName, methodName];
   }
 
   public getMethodId(moduleName: string, methodName: string): bigint {
-    this.runtime.assertIsValidModuleName(
-      this.runtime.definition.modules,
-      moduleName
-    );
+    this.runtime.assertIsValidModuleName(moduleName);
 
     return Poseidon.hash([
       stringToField(moduleName),

package/src/runtime/Runtime.ts

@@ -10,7 +10,6 @@ import {
   TypedClass,
   ZkProgrammable,
   PlainZkProgram,
-  WithZkProgrammable,
   AreProofsEnabled,
   ChildContainerProvider,
 } from "@proto-kit/common";
@@ -23,6 +22,7 @@ import {
 import {
   combineMethodName,
   isRuntimeMethod,
+  runtimeMethodTypeMetadataKey,
   toWrappedMethod,
   WrappedMethod,
 } from "../method/runtimeMethod";
@@ -32,6 +32,19 @@ import { RuntimeModule } from "./RuntimeModule";
 import { MethodIdResolver } from "./MethodIdResolver";
 import { RuntimeEnvironment } from "./RuntimeEnvironment";
 
+export function getAllPropertyNames(obj: any) {
+  let keys: (string | symbol)[] = [];
+  // if primitive (primitives still have keys) skip the first iteration
+  if (!(obj instanceof Object)) {
+    obj = Object.getPrototypeOf(obj);
+  }
+  while (obj) {
+    keys = keys.concat(Reflect.ownKeys(obj));
+    obj = Object.getPrototypeOf(obj);
+  }
+  return keys;
+}
+
 /**
  * Record of modules accepted by the Runtime module container.
  *
@@ -104,8 +117,9 @@ export class RuntimeZkProgrammable<
           (...args: unknown[]) => unknown
         >;
 
-        const modulePrototypeMethods =
-          Object.getOwnPropertyNames(modulePrototype);
+        const modulePrototypeMethods = getAllPropertyNames(runtimeModule).map(
+          (method) => method.toString()
+        );
 
         const moduleMethods = modulePrototypeMethods.reduce<Methods>(
           (allModuleMethods, methodName) => {
@@ -115,10 +129,16 @@ export class RuntimeZkProgrammable<
                 methodName
               );
               const method = modulePrototype[methodName];
+              const invocationType = Reflect.getMetadata(
+                runtimeMethodTypeMetadataKey,
+                runtimeModule,
+                methodName
+              );
+
               const wrappedMethod = Reflect.apply(
                 toWrappedMethod,
                 runtimeModule,
-                [methodName, method]
+                [methodName, method, { invocationType }]
               );
 
               // eslint-disable-next-line no-warning-comments
@@ -175,6 +195,7 @@ export class RuntimeZkProgrammable<
     return {
       compile: program.compile.bind(program),
       verify: program.verify.bind(program),
+      analyzeMethods: program.analyzeMethods.bind(program),
       Proof: SelfProof,
       methods,
     };
@@ -266,7 +287,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
     }
     const [moduleName, methodName] = methodDescriptor;
 
-    this.assertIsValidModuleName(this.definition.modules, moduleName);
+    this.assertIsValidModuleName(moduleName);
     const module = this.resolve(moduleName);
 
     // eslint-disable-next-line max-len

package/src/runtime/RuntimeModule.ts

@@ -6,6 +6,7 @@ import {
   StateService,
   RuntimeMethodExecutionContext,
   RuntimeMethodExecutionData,
+  RuntimeMethodExecutionDataStruct,
 } from "@proto-kit/protocol";
 
 import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
@@ -16,6 +17,7 @@ import type {
   RuntimeModulesRecord,
 } from "./Runtime";
 import { RuntimeEnvironment } from "./RuntimeEnvironment";
+import { Provable } from "o1js";
 
 const errors = {
   inputDataNotSet: () => new Error("Input data for runtime execution not set"),
@@ -56,15 +58,17 @@ export class RuntimeModule<
     this.runtimeMethodNames = methodNames ?? [];
   }
 
-  private getInputs(): RuntimeMethodExecutionData {
-    const { input } = container.resolve<RuntimeMethodExecutionContext>(
-      RuntimeMethodExecutionContext
-    );
+  public getInputs(): RuntimeMethodExecutionData {
+    return Provable.witness(RuntimeMethodExecutionDataStruct, () => {
+      const { input } = container.resolve<RuntimeMethodExecutionContext>(
+        RuntimeMethodExecutionContext
+      );
+      if (input === undefined) {
+        throw errors.inputDataNotSet();
+      }
 
-    if (input === undefined) {
-      throw errors.inputDataNotSet();
-    }
-    return input;
+      return input;
+    });
   }
 
   public get transaction(): RuntimeTransaction {

package/test/runtimeMethod.test.ts

@@ -9,7 +9,7 @@ import { container } from "tsyringe";
 import { AreProofsEnabled, log } from "@proto-kit/common";
 
 import { InMemoryStateService, MethodIdResolver, Runtime } from "../src";
-import { MethodParameterDecoder } from "../src/method/MethodParameterDecoder";
+import { MethodParameterEncoder } from "../src/method/MethodParameterEncoder";
 
 import { Balances } from "./modules/Balances";
 
@@ -42,7 +42,7 @@ describe("runtimeMethod", () => {
 
     const module = runtime.resolve("Balances");
 
-    const decoder = MethodParameterDecoder.fromMethod(module, "getBalance");
+    const decoder = MethodParameterEncoder.fromMethod(module, "getBalance");
     const recodedParameters = decoder.fromFields(
       parameters.flatMap((x) => x.toFields())
     );

package/src/method/MethodParameterDecoder.ts

@@ -1,62 +0,0 @@
-/* eslint-disable no-underscore-dangle */
-import { FlexibleProvable, ProvableExtended } from "o1js";
-
-import { RuntimeModule } from "../runtime/RuntimeModule";
-
-const errors = {
-  typeNotCompatible: (name: string) =>
-    new Error(
-      `Cannot decode type ${name}, it has to be either a Struct, CircuitValue or built-in snarkyjs type`
-    ),
-};
-
-export class MethodParameterDecoder {
-  public static fromMethod(target: RuntimeModule<unknown>, methodName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const paramtypes: ProvableExtended<unknown>[] = Reflect.getMetadata(
-      "design:paramtypes",
-      target,
-      methodName
-    );
-
-    if (paramtypes === undefined) {
-      throw new Error(
-        `Method with name ${methodName} doesn't exist on this module`
-      );
-    }
-
-    return new MethodParameterDecoder(paramtypes);
-  }
-
-  public static fieldSize(type: ProvableExtended<unknown>): number | undefined {
-    // as any, since we shouldn't be using this workaround in the first place
-    return (type as any).prototype._fields?.length ?? type.sizeInFields?.();
-  }
-
-  private constructor(private readonly types: ProvableExtended<unknown>[]) {}
-
-  public fromJSON(argsJSON: string[]): FlexibleProvable<unknown>[] {
-    return this.types.map((type, index) => {
-      // eslint-disable-next-line @typescript-eslint/init-declarations
-      let value: FlexibleProvable<unknown>;
-
-      try {
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        value = type.fromJSON(
-          JSON.parse(argsJSON[index])
-        ) as FlexibleProvable<unknown>;
-      } catch {
-        throw errors.typeNotCompatible(type.constructor.name);
-      }
-
-      return value;
-    });
-  }
-
-  public get fieldSize(): number {
-    return this.types
-      .map((type) => MethodParameterDecoder.fieldSize(type) ?? 0)
-      .reduce((a, b) => a + b, 0);
-  }
-}