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

package/dist/method/MethodParameterEncoder.js

@@ -1,9 +1,33 @@
-/* eslint-disable no-underscore-dangle */
-import { Proof, Provable, } 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,83 +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 { 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 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,
-        };
+            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, 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":"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"}
+{"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,4 +1,3 @@
-/* eslint-disable max-statements */
 import { Bool, Field, Poseidon } from "o1js";
 import { container } from "tsyringe";
 import { ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext, StateTransitionReductionList, } from "@proto-kit/protocol";
@@ -10,9 +9,7 @@ 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) {
+export function toStateTransitionsHash(stateTransitions) {
     const stateTransitionsHashList = new StateTransitionReductionList(ProvableStateTransition);
     return stateTransitions
         .map((stateTransition) => stateTransition.toProvable())
@@ -21,11 +18,10 @@ stateTransitions) {
 }
 export function toWrappedMethod(methodName, moduleMethod, options) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
-    const wrappedMethod = (...args) => {
-        Reflect.apply(moduleMethod, this, args);
+    const wrappedMethod = async (...args) => {
+        await Reflect.apply(moduleMethod, this, args);
         const { result: { stateTransitions, status }, } = executionContext.current();
         const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
-        const input = this.getInputs();
         const { name, runtime } = this;
         if (name === undefined) {
             throw errors.runtimeNameNotSet();
@@ -45,12 +41,9 @@ export function toWrappedMethod(methodName, moduleMethod, options) {
          * 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 args are statically sized
-        // i.e. the result of the if-statement will be the same for all executions
-        // of this method
-        const argsHash = (args ?? []).length > 0 ? Poseidon.hash(argsFields) : Field(0);
+        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));
@@ -103,7 +96,7 @@ 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) {
+        descriptor.value = async function value(...args) {
             const constructorName = this.name;
             /**
              * If its a top level method call, wrap it into a wrapped method,
@@ -122,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
@@ -144,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.map

@@ -1 +1 @@
-{"version":3,"file":"MethodIdResolver.d.ts","sourceRoot":"","sources":["../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAS5E,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAE/D;;;GAGG;AACH,qBACa,gBAAgB;IAMN,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAEpB;gBAG+B,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAkB5E;;;;OAIG;IACI,WAAW,IAAI,sBAAsB;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"}
+{"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

@@ -19,7 +19,7 @@ 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 = {};
@@ -44,6 +44,7 @@ let MethodIdResolver = class 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 {
@@ -87,4 +88,3 @@ MethodIdResolver = __decorate([
     __param(0, inject("Runtime")),
     __metadata("design:paramtypes", [Function])
 ], MethodIdResolver);
-export { MethodIdResolver };

package/dist/runtime/Runtime.d.ts

@@ -1,7 +1,7 @@
-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";
@@ -32,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>;
     /**
@@ -44,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
@@ -54,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,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"}
+{"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,23 +8,24 @@ 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, 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)) {
-        obj = Object.getPrototypeOf(obj);
+        currentPrototype = Object.getPrototypeOf(obj);
     }
-    while (obj) {
-        keys = keys.concat(Reflect.ownKeys(obj));
-        obj = 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;
 }
@@ -32,7 +33,6 @@ 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;
@@ -43,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);
@@ -53,10 +52,8 @@ 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 = getAllPropertyNames(runtimeModule).map((method) => method.toString());
@@ -66,7 +63,6 @@ export class RuntimeZkProgrammable extends ZkProgrammable {
                     const method = modulePrototype[methodName];
                     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);
                     return {
@@ -84,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;
@@ -109,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() {
@@ -127,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);
@@ -163,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}`);
@@ -195,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"}

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

package/dist/runtime/RuntimeModule.js

@@ -10,15 +10,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { ConfigurableModule } from "@proto-kit/common";
 import { container, injectable } from "tsyringe";
 import { RuntimeMethodExecutionContext, RuntimeMethodExecutionDataStruct, } from "@proto-kit/protocol";
-import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
 import { Provable } from "o1js";
+import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
 const errors = {
     inputDataNotSet: () => new Error("Input data for runtime execution not set"),
 };
 /**
  * Base class for runtime modules providing the necessary utilities.
  */
-let RuntimeModule = class RuntimeModule extends ConfigurableModule {
+export let RuntimeModule = class RuntimeModule extends ConfigurableModule {
     constructor() {
         super();
         /**
@@ -56,4 +56,3 @@ RuntimeModule = __decorate([
     injectable(),
     __metadata("design:paramtypes", [])
 ], RuntimeModule);
-export { RuntimeModule };

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

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

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

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

package/dist/src/factories/MethodIdFactory.js

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

package/dist/src/index.d.ts

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

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

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

package/dist/src/index.js

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