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

package/dist/method/MethodParameterEncoder.js

@@ -1,9 +1,33 @@
-/* eslint-disable no-underscore-dangle */
-import { Proof } from "o1js";
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import { Proof, Provable, DynamicProof, } from "o1js";
+import { filterNonUndefined, } from "@proto-kit/common";
 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}` : ""}`),
 };
+function isProofType(type) {
+    return type.prototype instanceof Proof;
+}
+function isDynamicProofType(type) {
+    return (type.prototype instanceof DynamicProof);
+}
+function isProofBaseType(type) {
+    return isProofType(type) || isDynamicProofType(type);
+}
+function getAllPropertyNamesOfPrototypeChain(type) {
+    if (type === undefined || type === null) {
+        return [];
+    }
+    return Object.getOwnPropertyNames(type).concat(...getAllPropertyNamesOfPrototypeChain(Object.getPrototypeOf(type)));
+}
+function isFlexibleProvablePure(type) {
+    // The required properties are defined on the prototype for Structs and CircuitValues
+    // but on the constructor function itself for Field and Bool
+    // For aliases like Balance in library, it can even be 2 steps upwards the prototype chain
+    const props = getAllPropertyNamesOfPrototypeChain(type);
+    const mandatory = ["toFields", "fromFields", "sizeInFields"];
+    return mandatory.every((prop) => props.includes(prop));
+}
 export class MethodParameterEncoder {
     static fromMethod(target, methodName) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -11,80 +35,130 @@ export class MethodParameterEncoder {
         if (paramtypes === undefined) {
             throw new Error(`Method with name ${methodName} doesn't exist on this module`);
         }
+        const indizes = paramtypes
+            .map((type, index) => {
+            if (isProofBaseType(type) || isFlexibleProvablePure(type)) {
+                return undefined;
+            }
+            return `${index}`;
+        })
+            .filter(filterNonUndefined);
+        if (indizes.length > 0) {
+            const indexString = indizes.reduce((a, b) => `${a}, ${b}`);
+            throw new Error(`Not all arguments of method '${target.name}.${methodName}' are provable types or proofs (indizes: [${indexString}])`);
+        }
         return new MethodParameterEncoder(paramtypes);
     }
     static fieldSize(type) {
+        if (isProofBaseType(type)) {
+            return ((MethodParameterEncoder.fieldSize(type.publicInputType) ?? 0) +
+                (MethodParameterEncoder.fieldSize(type.publicOutputType) ?? 0));
+        }
         // as any, since we shouldn't be using this workaround in the first place
-        return type.prototype._fields?.length ?? type.sizeInFields?.();
+        return 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);
+    decode(fields, auxiliary) {
+        if (fields.length < this.fieldSize()) {
+            throw errors.fieldLengthNotMatching(this.fieldSize(), fields.length);
         }
         let stack = fields.slice();
-        return this.types.map((type) => {
+        const auxiliaryStack = auxiliary.slice();
+        return Promise.all(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, []);
-        });
+            // Decode proof
+            if (isProofBaseType(type)) {
+                const auxiliaryData = auxiliaryStack.shift();
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const proofData = JSON.parse(auxiliaryData);
+                const inputFieldSize = MethodParameterEncoder.fieldSize(type.publicInputType);
+                const input = structFields
+                    .slice(0, inputFieldSize)
+                    .map((x) => x.toString());
+                const output = structFields
+                    .slice(inputFieldSize)
+                    .map((x) => x.toString());
+                // fromJSON has incompatible signature for Proof and DynamicProof
+                if (isProofType(type)) {
+                    return type.fromJSON({
+                        ...proofData,
+                        publicInput: input,
+                        publicOutput: output,
+                    });
+                }
+                if (isDynamicProofType(type)) {
+                    return type.fromJSON({
+                        ...proofData,
+                        publicInput: input,
+                        publicOutput: output,
+                    });
+                }
+            }
+            return type.fromFields(structFields);
+        }));
     }
+    /**
+     * Variant of encode() for provable code that skips the unprovable
+     * json encoding
+     */
     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) {
+        return args
+            .map((argument, index) => {
+            if (argument instanceof Proof || argument instanceof DynamicProof) {
                 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);
-        });
-        const argsJSON = args.map((argument, index) => {
-            if (argument instanceof Proof) {
-                return JSON.stringify(argument.toJSON());
+                const { publicOutputType, publicInputType } = argumentType;
+                const inputFields = 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                publicInputType?.toFields(argument.publicInput) ?? [];
+                const outputFields = 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                publicOutputType?.toFields(argument.publicOutput) ?? [];
+                let auxiliary = "";
+                // Has to be asProver, because this function will be called by runtimeMethod
+                // to transform the args into a Field[] to compute the argsHash
+                // In this case, the auxiliary might be empty, but it isn't used by that method anyways
+                Provable.asProver(() => {
+                    const jsonProof = argument.toJSON();
+                    auxiliary = JSON.stringify({
+                        proof: jsonProof.proof,
+                        maxProofsVerified: jsonProof.maxProofsVerified,
+                    });
+                });
+                return {
+                    fields: [...inputFields, ...outputFields],
+                    auxiliary,
+                };
             }
             const argumentType = this.types[index];
-            return JSON.stringify(argumentType.toJSON(argument));
-        });
-        return {
-            argsFields,
-            argsJSON,
-        };
+            return {
+                fields: argumentType.toFields(argument),
+                auxiliary: undefined,
+            };
+        })
+            .reduce((a, b) => {
+            return {
+                fields: [...a.fields, ...b.fields],
+                auxiliary: b.auxiliary !== undefined
+                    ? [...a.auxiliary, b.auxiliary]
+                    : a.auxiliary,
+            };
+        }, { fields: [], auxiliary: [] });
     }
-    get fieldSize() {
+    fieldSize() {
         return this.types
             .map((type) => MethodParameterEncoder.fieldSize(type) ?? 0)
             .reduce((a, b) => a + b, 0);
     }
 }
+/* eslint-enable @typescript-eslint/consistent-type-assertions */

package/dist/method/runtimeMethod.d.ts

@@ -1,11 +1,12 @@
 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/field.js").Field;
+export declare function toStateTransitionsHash(stateTransitions: StateTransition<any>[]): import("o1js/dist/node/lib/provable/field.js").Field;
 export type WrappedMethod = (...args: ArgumentTypes) => MethodPublicOutput;
-export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: ArgumentTypes) => unknown, methodArguments: ArgumentTypes, options: {
+export type AsyncWrappedMethod = (...args: ArgumentTypes) => Promise<MethodPublicOutput>;
+export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: ArgumentTypes) => Promise<any>, options: {
     invocationType: RuntimeMethodInvocationType;
-}): WrappedMethod;
+}): AsyncWrappedMethod;
 export declare function combineMethodName(runtimeModuleName: string, methodName: string): string;
 export declare const runtimeMethodMetadataKey = "yab-method";
 export declare const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
@@ -20,6 +21,6 @@ export declare const runtimeMethodTypeMetadataKey = "proto-kit-runtime-method-ty
  */
 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;
+export declare function runtimeMessage(): (target: RuntimeModule<unknown>, methodName: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>) => void;
+export declare function runtimeMethod(): (target: RuntimeModule<unknown>, methodName: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>) => 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":"AAUA,OAAO,EACL,eAAe,EAGf,kBAAkB,EAGnB,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,EAC9B,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;AAwG3E,wBAAgB,cAAc,iGAI7B;AAED,wBAAgB,aAAa,iGAI5B"}
+{"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,CA4EpB;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;AA0G3E,wBAAgB,cAAc,wIAI7B;AAED,wBAAgB,aAAa,wIAI5B"}

package/dist/method/runtimeMethod.js

@@ -1,7 +1,6 @@
-/* eslint-disable max-statements */
-import { Bool, Field, Poseidon, } 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 = {
@@ -10,24 +9,19 @@ const errors = {
     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(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-stateTransitions) {
-    const stateTransitionsHashList = new DefaultProvableHashList(ProvableStateTransition);
+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, methodArguments, options) {
+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 wrappedMethod = async (...args) => {
+        await Reflect.apply(moduleMethod, this, args);
+        const { result: { stateTransitions, status }, } = executionContext.current();
         const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
-        if (input === undefined) {
-            throw errors.methodInputsNotProvided();
-        }
         const { name, runtime } = this;
         if (name === undefined) {
             throw errors.runtimeNameNotSet();
@@ -47,12 +41,9 @@ export function toWrappedMethod(methodName, moduleMethod, methodArguments, optio
          * Use the type info obtained previously to convert
          * the args passed to fields
          */
-        const { argsFields } = MethodParameterEncoder.fromMethod(this, methodName).encode(args);
+        const { fields } = 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
-        // 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);
+        const argsHash = Poseidon.hash(fields);
         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));
@@ -105,8 +96,8 @@ function runtimeMethodInternal(options) {
         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;
+        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().
@@ -117,7 +108,6 @@ function runtimeMethodInternal(options) {
             const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
                 methodName,
                 simulatedMethod,
-                args,
                 options,
             ]);
             /**
@@ -125,11 +115,9 @@ function runtimeMethodInternal(options) {
              * RuntimeMethodExecutionContext state, meaning it enters and exits
              * the context properly.
              */
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             async function prover() {
                 executionContext.beforeMethod(constructorName, methodName, args);
                 const innerProver = toProver(combineMethodName(constructorName, methodName), simulatedWrappedMethod, false, ...args).bind(this);
-                // eslint-disable-next-line @typescript-eslint/init-declarations
                 let result;
                 try {
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -147,10 +135,9 @@ function runtimeMethodInternal(options) {
                 }
                 executionContext.setProver(prover.bind(this.runtime.zkProgrammable));
             }
-            // eslint-disable-next-line @typescript-eslint/init-declarations
             let result;
             try {
-                result = Reflect.apply(simulatedMethod, this, args);
+                result = await Reflect.apply(simulatedMethod, this, args);
             }
             finally {
                 executionContext.afterMethod();

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;IAkBrE,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"}
+{"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/runtime/MethodIdResolver.js

@@ -10,14 +10,16 @@ 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
  */
-let MethodIdResolver = class MethodIdResolver {
+export let MethodIdResolver = class MethodIdResolver {
     constructor(runtime) {
         this.runtime = runtime;
         this.dictionary = {};
@@ -32,6 +34,38 @@ 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) => {
+                // 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) {
@@ -54,4 +88,3 @@ MethodIdResolver = __decorate([
     __param(0, inject("Runtime")),
     __metadata("design:paramtypes", [Function])
 ], MethodIdResolver);
-export { MethodIdResolver };

package/dist/runtime/Runtime.d.ts

@@ -1,10 +1,11 @@
-import { Experimental } from "o1js";
+import { ZkProgram } from "o1js";
 import { DependencyContainer } from "tsyringe";
 import { StringKeyOf, ModuleContainer, ModulesConfig, ModulesRecord, TypedClass, ZkProgrammable, PlainZkProgram, AreProofsEnabled, ChildContainerProvider } from "@proto-kit/common";
-import { MethodPublicOutput, StateServiceProvider, StateService } from "@proto-kit/protocol";
+import { MethodPublicOutput, StateServiceProvider, SimpleAsyncStateService } from "@proto-kit/protocol";
 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.
  *
@@ -31,7 +32,7 @@ export declare class RuntimeZkProgrammable<Modules extends RuntimeModulesRecord>
  */
 export declare class Runtime<Modules extends RuntimeModulesRecord> extends ModuleContainer<Modules> implements RuntimeEnvironment {
     static from<Modules extends RuntimeModulesRecord>(definition: RuntimeDefinition<Modules>): TypedClass<Runtime<Modules>>;
-    program?: ReturnType<typeof Experimental.ZkProgram>;
+    program?: ReturnType<typeof ZkProgram>;
     definition: RuntimeDefinition<Modules>;
     zkProgrammable: ZkProgrammable<undefined, MethodPublicOutput>;
     /**
@@ -43,7 +44,7 @@ export declare class Runtime<Modules extends RuntimeModulesRecord> extends Modul
     create(childContainerProvider: ChildContainerProvider): void;
     get appChain(): AreProofsEnabled | undefined;
     get stateServiceProvider(): StateServiceProvider;
-    get stateService(): StateService;
+    get stateService(): SimpleAsyncStateService;
     get methodIdResolver(): MethodIdResolver;
     /**
      * @returns The dependency injection container of this runtime
@@ -53,7 +54,7 @@ export declare class Runtime<Modules extends RuntimeModulesRecord> extends Modul
      * @param methodId The encoded name of the method to call.
      * Encoding: "stringToField(module.name) << 128 + stringToField(method-name)"
      */
-    getMethodById(methodId: bigint): ((...args: unknown[]) => unknown) | undefined;
+    getMethodById(methodId: bigint): ((...args: unknown[]) => Promise<unknown>) | undefined;
     /**
      * Add a name and other respective properties required by RuntimeModules,
      * that come from the current Runtime

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":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACjC,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,uBAAuB,EACxB,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,uBAa3C;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;IAC3B,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;CAuHzE;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,SAAS,CAAC,CAAC;IAEvC,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;IAOlD,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;IAM5D,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAItD;IAED,IAAW,YAAY,IAAI,uBAAuB,CAEjD;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,OAAO,CAAC,CAAC,GAAG,SAAS;IAsBzD;;;;;;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

@@ -8,19 +8,31 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 var Runtime_1;
-// eslint-disable-next-line max-len
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,max-lines */
-import { Experimental } from "o1js";
+/* eslint-disable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument */
+import { ZkProgram } 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 currentPrototype = obj;
+    let keys = [];
+    // if primitive (primitives still have keys) skip the first iteration
+    if (!(obj instanceof Object)) {
+        currentPrototype = Object.getPrototypeOf(obj);
+    }
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    while (currentPrototype) {
+        keys = keys.concat(Reflect.ownKeys(currentPrototype));
+        currentPrototype = Object.getPrototypeOf(currentPrototype);
+    }
+    return keys;
+}
 const errors = {
     methodNotFound: (methodKey) => new Error(`Unable to find method with id ${methodKey}`),
 };
 export class RuntimeZkProgrammable extends ZkProgrammable {
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
     constructor(runtime) {
         super();
         this.runtime = runtime;
@@ -31,8 +43,7 @@ export class RuntimeZkProgrammable extends ZkProgrammable {
     zkProgramFactory() {
         // We need to use explicit type annotations here,
         // therefore we can't use destructuring
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define,prefer-destructuring,putout/putout
+        // eslint-disable-next-line prefer-destructuring
         const runtime = this.runtime;
         const runtimeMethods = runtime.runtimeModuleNames.reduce((allMethods, runtimeModuleName) => {
             runtime.isValidModuleName(runtime.definition.modules, runtimeModuleName);
@@ -41,19 +52,17 @@ export class RuntimeZkProgrammable extends ZkProgrammable {
              * regarding resolving only known modules. We assert in the line above
              * but we cast it to any anyways to satisfy the proof system.
              */
-            // eslint-disable-next-line max-len
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             const runtimeModule = runtime.resolve(runtimeModuleName);
-            // 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]);
-                    // eslint-disable-next-line no-warning-comments
+                    const invocationType = Reflect.getMetadata(runtimeMethodTypeMetadataKey, runtimeModule, methodName);
+                    const wrappedMethod = Reflect.apply(toWrappedMethod, runtimeModule, [methodName, method, { invocationType }]);
                     // TODO: find out how to import the Tuple type
                     const privateInputs = Reflect.getMetadata("design:paramtypes", runtimeModule, methodName);
                     return {
@@ -71,14 +80,13 @@ export class RuntimeZkProgrammable extends ZkProgrammable {
                 ...moduleMethods,
             };
         }, {});
-        const sortedRuntimeMethods = Object.fromEntries(
-        // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
-        Object.entries(runtimeMethods).sort());
-        const program = Experimental.ZkProgram({
+        const sortedRuntimeMethods = Object.fromEntries(Object.entries(runtimeMethods).sort());
+        const program = ZkProgram({
+            name: "RuntimeProgram",
             publicOutput: MethodPublicOutput,
             methods: sortedRuntimeMethods,
         });
-        const SelfProof = Experimental.ZkProgram.Proof(program);
+        const SelfProof = ZkProgram.Proof(program);
         const methods = Object.keys(sortedRuntimeMethods).reduce((boundMethods, methodName) => {
             boundMethods[methodName] = program[methodName].bind(program);
             return boundMethods;
@@ -86,6 +94,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,
         };
@@ -95,7 +104,7 @@ export class RuntimeZkProgrammable extends ZkProgrammable {
  * Wrapper for an application specific runtime, which helps orchestrate
  * runtime modules into an interoperable runtime.
  */
-let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
+export let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
     static from(definition) {
         return class RuntimeScoped extends Runtime_1 {
             constructor() {
@@ -113,7 +122,6 @@ let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
         this.definition = definition;
         this.zkProgrammable = new RuntimeZkProgrammable(this);
     }
-    // eslint-disable-next-line no-warning-comments
     // TODO Remove after changing DFs to type-based approach
     create(childContainerProvider) {
         super.create(childContainerProvider);
@@ -149,8 +157,7 @@ let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
         const [moduleName, methodName] = methodDescriptor;
         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
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const method = module[methodName];
         if (method === undefined) {
             throw errors.methodNotFound(`${moduleName}.${methodName}`);
@@ -181,4 +188,4 @@ Runtime = Runtime_1 = __decorate([
     injectable(),
     __metadata("design:paramtypes", [Object])
 ], Runtime);
-export { Runtime };
+/* eslint-enable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument */

package/dist/runtime/RuntimeEnvironment.d.ts

@@ -1,9 +1,9 @@
 import { AreProofsEnabled, WithZkProgrammable } from "@proto-kit/common";
-import { MethodPublicOutput, StateService, StateServiceProvider } from "@proto-kit/protocol";
+import { MethodPublicOutput, SimpleAsyncStateService, StateServiceProvider } from "@proto-kit/protocol";
 import { MethodIdResolver } from "./MethodIdResolver";
 export interface RuntimeEnvironment extends WithZkProgrammable<undefined, MethodPublicOutput> {
     get appChain(): AreProofsEnabled | undefined;
-    get stateService(): StateService;
+    get stateService(): SimpleAsyncStateService;
     get stateServiceProvider(): StateServiceProvider;
     get methodIdResolver(): MethodIdResolver;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"RuntimeEnvironment.d.ts","sourceRoot":"","sources":["../../src/runtime/RuntimeEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,WAAW,kBACf,SAAQ,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACzD,IAAI,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAAC;IAC7C,IAAI,YAAY,IAAI,YAAY,CAAC;IACjC,IAAI,oBAAoB,IAAI,oBAAoB,CAAC;IACjD,IAAI,gBAAgB,IAAI,gBAAgB,CAAC;CAC1C"}
+{"version":3,"file":"RuntimeEnvironment.d.ts","sourceRoot":"","sources":["../../src/runtime/RuntimeEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,WAAW,kBACf,SAAQ,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACzD,IAAI,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAAC;IAC7C,IAAI,YAAY,IAAI,uBAAuB,CAAC;IAC5C,IAAI,oBAAoB,IAAI,oBAAoB,CAAC;IACjD,IAAI,gBAAgB,IAAI,gBAAgB,CAAC;CAC1C"}