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

package/dist/src/runtime/Runtime.js

@@ -0,0 +1,215 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var Runtime_1;
+/* 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)) {
+        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 {
+    constructor(runtime) {
+        super();
+        Object.defineProperty(this, "runtime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: runtime
+        });
+    }
+    get appChain() {
+        return this.runtime.appChain;
+    }
+    zkProgramFactory() {
+        // We need to use explicit type annotations here,
+        // therefore we can't use destructuring
+        // eslint-disable-next-line prefer-destructuring
+        const runtime = this.runtime;
+        const runtimeMethods = runtime.runtimeModuleNames.reduce((allMethods, runtimeModuleName) => {
+            runtime.isValidModuleName(runtime.definition.modules, runtimeModuleName);
+            /**
+             * Couldnt find a better way to circumvent the type assertion
+             * 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 @typescript-eslint/consistent-type-assertions
+            const runtimeModule = runtime.resolve(runtimeModuleName);
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const modulePrototype = Object.getPrototypeOf(runtimeModule);
+            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 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 {
+                        ...allModuleMethods,
+                        [combinedMethodName]: {
+                            privateInputs,
+                            method: async () => wrappedMethod(),
+                        },
+                    };
+                }
+                return allModuleMethods;
+            }, {});
+            return {
+                ...allMethods,
+                ...moduleMethods,
+            };
+        }, {});
+        const sortedRuntimeMethods = Object.fromEntries(Object.entries(runtimeMethods).sort());
+        const program = ZkProgram({
+            name: "RuntimeProgram",
+            publicOutput: MethodPublicOutput,
+            methods: sortedRuntimeMethods,
+        });
+        const SelfProof = ZkProgram.Proof(program);
+        const methods = Object.keys(sortedRuntimeMethods).reduce((boundMethods, methodName) => {
+            boundMethods[methodName] = program[methodName].bind(program);
+            return boundMethods;
+        }, {});
+        return {
+            compile: program.compile.bind(program),
+            verify: program.verify.bind(program),
+            analyzeMethods: program.analyzeMethods.bind(program),
+            Proof: SelfProof,
+            methods,
+        };
+    }
+}
+/**
+ * Wrapper for an application specific runtime, which helps orchestrate
+ * runtime modules into an interoperable runtime.
+ */
+export let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
+    static from(definition) {
+        return class RuntimeScoped extends Runtime_1 {
+            constructor() {
+                super(definition);
+            }
+        };
+    }
+    /**
+     * Creates a new Runtime from the provided config
+     *
+     * @param modules - Configuration object for the constructed Runtime
+     */
+    constructor(definition) {
+        super(definition);
+        // runtime modules composed into a ZkProgram
+        Object.defineProperty(this, "program", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "definition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "zkProgrammable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.definition = definition;
+        this.zkProgrammable = new RuntimeZkProgrammable(this);
+    }
+    // TODO Remove after changing DFs to type-based approach
+    create(childContainerProvider) {
+        super.create(childContainerProvider);
+        this.useDependencyFactory(this.container.resolve(MethodIdFactory));
+    }
+    get appChain() {
+        return this.container.resolve("AreProofsEnabled");
+    }
+    get stateServiceProvider() {
+        return this.dependencyContainer.resolve("StateServiceProvider");
+    }
+    get stateService() {
+        return this.stateServiceProvider.stateService;
+    }
+    get methodIdResolver() {
+        return this.container.resolve("MethodIdResolver");
+    }
+    /**
+     * @returns The dependency injection container of this runtime
+     */
+    get dependencyContainer() {
+        return this.container;
+    }
+    /**
+     * @param methodId The encoded name of the method to call.
+     * Encoding: "stringToField(module.name) << 128 + stringToField(method-name)"
+     */
+    getMethodById(methodId) {
+        const methodDescriptor = this.methodIdResolver.getMethodNameFromId(methodId);
+        if (methodDescriptor === undefined) {
+            return undefined;
+        }
+        const [moduleName, methodName] = methodDescriptor;
+        this.assertIsValidModuleName(moduleName);
+        const module = this.resolve(moduleName);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const method = module[methodName];
+        if (method === undefined) {
+            throw errors.methodNotFound(`${moduleName}.${methodName}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return method.bind(module);
+    }
+    /**
+     * Add a name and other respective properties required by RuntimeModules,
+     * that come from the current Runtime
+     *
+     * @param moduleName - Name of the runtime module to decorate
+     * @param containedModule
+     */
+    decorateModule(moduleName, containedModule) {
+        containedModule.name = moduleName;
+        containedModule.runtime = this;
+        super.decorateModule(moduleName, containedModule);
+    }
+    /**
+     * @returns A list of names of all the registered module names
+     */
+    get runtimeModuleNames() {
+        return Object.keys(this.definition.modules);
+    }
+};
+Runtime = Runtime_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], Runtime);
+/* eslint-enable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument */

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

@@ -0,0 +1,10 @@
+import { AreProofsEnabled, WithZkProgrammable } from "@proto-kit/common";
+import { MethodPublicOutput, StateService, StateServiceProvider } from "@proto-kit/protocol";
+import { MethodIdResolver } from "./MethodIdResolver";
+export interface RuntimeEnvironment extends WithZkProgrammable<undefined, MethodPublicOutput> {
+    get appChain(): AreProofsEnabled | undefined;
+    get stateService(): StateService;
+    get stateServiceProvider(): StateServiceProvider;
+    get methodIdResolver(): MethodIdResolver;
+}
+//# sourceMappingURL=RuntimeEnvironment.d.ts.map

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

@@ -0,0 +1 @@
+{"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,YAAY,EACZ,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,YAAY,CAAC;IACjC,IAAI,oBAAoB,IAAI,oBAAoB,CAAC;IACjD,IAAI,gBAAgB,IAAI,gBAAgB,CAAC;CAC1C"}

package/dist/src/runtime/RuntimeEnvironment.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,26 @@
+import { ConfigurableModule, NoConfig, Presets } from "@proto-kit/common";
+import { NetworkState, RuntimeTransaction, RuntimeMethodExecutionData } from "@proto-kit/protocol";
+import { RuntimeEnvironment } from "./RuntimeEnvironment";
+/**
+ * Base class for runtime modules providing the necessary utilities.
+ */
+export declare class RuntimeModule<Config = NoConfig> extends ConfigurableModule<Config> {
+    static presets: Presets<unknown>;
+    /**
+     * Holds all method names that are callable throw transactions
+     */
+    readonly runtimeMethodNames: string[];
+    /**
+     * This property exists only to typecheck that the RuntimeModule
+     * was extended correctly in e.g. a decorator. We need at least
+     * one non-optional property in this class to make the typechecking work.
+     */
+    isRuntimeModule: boolean;
+    name?: string;
+    runtime?: RuntimeEnvironment;
+    constructor();
+    getInputs(): RuntimeMethodExecutionData;
+    get transaction(): RuntimeTransaction;
+    get network(): NetworkState;
+}
+//# sourceMappingURL=RuntimeModule.d.ts.map

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

@@ -0,0 +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,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/src/runtime/RuntimeModule.js

@@ -0,0 +1,85 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ConfigurableModule } from "@proto-kit/common";
+import { container, injectable } from "tsyringe";
+import { RuntimeMethodExecutionContext, RuntimeMethodExecutionDataStruct, } from "@proto-kit/protocol";
+import { Provable } from "o1js";
+import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
+const errors = {
+    inputDataNotSet: () => new Error("Input data for runtime execution not set"),
+};
+/**
+ * Base class for runtime modules providing the necessary utilities.
+ */
+export let RuntimeModule = class RuntimeModule extends ConfigurableModule {
+    constructor() {
+        super();
+        /**
+         * Holds all method names that are callable throw transactions
+         */
+        Object.defineProperty(this, "runtimeMethodNames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        /**
+         * This property exists only to typecheck that the RuntimeModule
+         * was extended correctly in e.g. a decorator. We need at least
+         * one non-optional property in this class to make the typechecking work.
+         */
+        Object.defineProperty(this, "isRuntimeModule", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runtime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const methodNames = Reflect.getMetadata(runtimeMethodNamesMetadataKey, this);
+        this.runtimeMethodNames = methodNames ?? [];
+    }
+    getInputs() {
+        return Provable.witness(RuntimeMethodExecutionDataStruct, () => {
+            const { input } = container.resolve(RuntimeMethodExecutionContext);
+            if (input === undefined) {
+                throw errors.inputDataNotSet();
+            }
+            return input;
+        });
+    }
+    get transaction() {
+        return this.getInputs().transaction;
+    }
+    get network() {
+        return this.getInputs().networkState;
+    }
+};
+Object.defineProperty(RuntimeModule, "presets", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {}
+});
+RuntimeModule = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], RuntimeModule);

package/dist/src/state/InMemoryStateService.d.ts

@@ -0,0 +1,15 @@
+import { Field } from "o1js";
+import { StateService } from "@proto-kit/protocol";
+/**
+ * Naive implementation of an in-memory variant of the StateService interface
+ */
+export declare class InMemoryStateService implements StateService {
+    /**
+     * This mapping container null values if the specific entry has been deleted.
+     * This is used by the CachedState service to keep track of deletions
+     */
+    values: Record<string, Field[] | null>;
+    get(key: Field): Field[] | undefined;
+    set(key: Field, value: Field[] | undefined): void;
+}
+//# sourceMappingURL=InMemoryStateService.d.ts.map

package/dist/src/state/InMemoryStateService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryStateService.d.ts","sourceRoot":"","sources":["../../../src/state/InMemoryStateService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;GAEG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD;;;OAGG;IACI,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,CAAM;IAE5C,GAAG,CAAC,GAAG,EAAE,KAAK,GAAG,KAAK,EAAE,GAAG,SAAS;IAIpC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,SAAS;CAOlD"}

package/dist/src/state/InMemoryStateService.js

@@ -0,0 +1,28 @@
+/**
+ * Naive implementation of an in-memory variant of the StateService interface
+ */
+export class InMemoryStateService {
+    constructor() {
+        /**
+         * This mapping container null values if the specific entry has been deleted.
+         * This is used by the CachedState service to keep track of deletions
+         */
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    get(key) {
+        return this.values[key.toString()] ?? undefined;
+    }
+    set(key, value) {
+        if (value === undefined) {
+            this.values[key.toString()] = null;
+        }
+        else {
+            this.values[key.toString()] = value;
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { RuntimeModule } from "../runtime/RuntimeModule.js";
+/**
+ * Decorates a runtime module property as state, passing down some
+ * underlying values to improve developer experience.
+ */
+export declare function state(): <TargetRuntimeModule extends RuntimeModule<unknown>>(target: TargetRuntimeModule, propertyKey: string) => void;
+//# sourceMappingURL=decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../../src/state/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAgBjE;;;GAGG;AACH,wBAAgB,KAAK,mGAGJ,MAAM,UAmCtB"}

package/dist/src/state/decorator.js

@@ -0,0 +1,39 @@
+import { Path } from "@proto-kit/protocol";
+const errors = {
+    missingName: (className) => new Error(`Unable to provide a unique identifier for state, ${className} is missing a name. 
+      Did you forget to extend your runtime module with 'extends RuntimeModule'?`),
+    missingRuntime: (className) => new Error(`Unable to provide 'runtime' for state, ${className} is missing a name. 
+      Did you forget to extend your runtime module with 'extends RuntimeModule'?`),
+};
+/**
+ * Decorates a runtime module property as state, passing down some
+ * underlying values to improve developer experience.
+ */
+export function state() {
+    return (target, propertyKey) => {
+        let value;
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            get: function get() {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const self = this;
+                if (self.name === undefined) {
+                    throw errors.missingName(self.constructor.name);
+                }
+                if (!self.runtime) {
+                    throw errors.missingRuntime(self.constructor.name);
+                }
+                const path = Path.fromProperty(self.name, propertyKey);
+                if (value) {
+                    value.path = path;
+                    // TODO: why is this complaining about `any`?
+                    value.stateServiceProvider = self.runtime.stateServiceProvider;
+                }
+                return value;
+            },
+            set: (newValue) => {
+                value = newValue;
+            },
+        });
+    };
+}

package/dist/state/InMemoryStateService.d.ts

@@ -1,11 +1,15 @@
 import { Field } from "o1js";
-import { StateService } from "@proto-kit/protocol";
+import { SimpleAsyncStateService } from "@proto-kit/protocol";
 /**
- * Naive implementation of a StateService for testing purposes
+ * Naive implementation of an in-memory variant of the StateService interface
  */
-export declare class InMemoryStateService implements StateService {
-    values: Record<string, Field[] | undefined>;
-    get(key: Field): Field[] | undefined;
-    set(key: Field, value: Field[] | undefined): void;
+export declare class InMemoryStateService implements SimpleAsyncStateService {
+    /**
+     * This mapping container null values if the specific entry has been deleted.
+     * This is used by the CachedState service to keep track of deletions
+     */
+    values: Record<string, Field[] | null>;
+    get(key: Field): Promise<Field[] | undefined>;
+    set(key: Field, value: Field[] | undefined): Promise<void>;
 }
 //# sourceMappingURL=InMemoryStateService.d.ts.map

package/dist/state/InMemoryStateService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InMemoryStateService.d.ts","sourceRoot":"","sources":["../../src/state/InMemoryStateService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;GAEG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IAChD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,CAAM;IAEjD,GAAG,CAAC,GAAG,EAAE,KAAK,GAAG,KAAK,EAAE,GAAG,SAAS;IAIpC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,SAAS;CAWlD"}
+{"version":3,"file":"InMemoryStateService.d.ts","sourceRoot":"","sources":["../../src/state/InMemoryStateService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D;;GAEG;AACH,qBAAa,oBAAqB,YAAW,uBAAuB;IAClE;;;OAGG;IACI,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,CAAM;IAEtC,GAAG,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,SAAS,CAAC;IAI7C,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,SAAS;CAOxD"}

package/dist/state/InMemoryStateService.js

@@ -1,18 +1,20 @@
 /**
- * Naive implementation of a StateService for testing purposes
+ * Naive implementation of an in-memory variant of the StateService interface
  */
 export class InMemoryStateService {
     constructor() {
+        /**
+         * This mapping container null values if the specific entry has been deleted.
+         * This is used by the CachedState service to keep track of deletions
+         */
         this.values = {};
     }
-    get(key) {
-        return this.values[key.toString()];
+    async get(key) {
+        return this.values[key.toString()] ?? undefined;
     }
-    set(key, value) {
-        if (value === undefined &&
-            Object.prototype.hasOwnProperty.call(this.values, key.toString())) {
-            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-            delete this.values[key.toString()];
+    async set(key, value) {
+        if (value === undefined) {
+            this.values[key.toString()] = null;
         }
         else {
             this.values[key.toString()] = value;

package/dist/state/decorator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/state/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAgBjE;;;GAGG;AACH,wBAAgB,KAAK,mGAGJ,MAAM,UAqCtB"}
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/state/decorator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAgBjE;;;GAGG;AACH,wBAAgB,KAAK,mGAGJ,MAAM,UAmCtB"}

package/dist/state/decorator.js

@@ -11,12 +11,10 @@ const errors = {
  */
 export function state() {
     return (target, propertyKey) => {
-        // eslint-disable-next-line @typescript-eslint/init-declarations
         let value;
         Object.defineProperty(target, propertyKey, {
             enumerable: true,
             get: function get() {
-                // eslint-disable-next-line max-len
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 const self = this;
                 if (self.name === undefined) {
@@ -28,7 +26,6 @@ export function state() {
                 const path = Path.fromProperty(self.name, propertyKey);
                 if (value) {
                     value.path = path;
-                    // eslint-disable-next-line no-warning-comments
                     // TODO: why is this complaining about `any`?
                     value.stateServiceProvider = self.runtime.stateServiceProvider;
                 }

package/dist/test/Runtime.test.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+//# sourceMappingURL=Runtime.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Runtime.test.d.ts","sourceRoot":"","sources":["../../test/Runtime.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/test/Runtime.test.js

@@ -0,0 +1,24 @@
+import "reflect-metadata";
+import { Balances } from "./modules/Balances";
+import { createTestingRuntime } from "./TestingRuntime";
+describe("runtime", () => {
+    it("should encode methodnames correctly", () => {
+        expect.assertions(2);
+        const { runtime } = createTestingRuntime({
+            Balances,
+        }, {
+            Balances: {},
+        });
+        const balances = runtime.resolve("Balances");
+        expect(balances).toBeDefined();
+        console.log(Object.keys(balances));
+        console.log(balances.getTotalSupply);
+        const moduleName = "Balances";
+        const methodName = "getTotalSupply";
+        const methodId = runtime.dependencyContainer
+            .resolve("MethodIdResolver")
+            .getMethodId(moduleName, methodName);
+        const method = runtime.getMethodById(methodId);
+        expect(method).toBeDefined();
+    });
+});

package/dist/test/TestingRuntime.d.ts

@@ -0,0 +1,7 @@
+import { ModulesConfig } from "@proto-kit/common";
+import { InMemoryStateService, Runtime, RuntimeModulesRecord } from "../src";
+export declare function createTestingRuntime<Modules extends RuntimeModulesRecord>(modules: Modules, config: ModulesConfig<Modules>): {
+    runtime: Runtime<Modules>;
+    state: InMemoryStateService;
+};
+//# sourceMappingURL=TestingRuntime.d.ts.map

package/dist/test/TestingRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestingRuntime.d.ts","sourceRoot":"","sources":["../../test/TestingRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIlD,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAE7E,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,oBAAoB,EACvE,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAgCA"}

package/dist/test/TestingRuntime.js

@@ -0,0 +1,29 @@
+import { StateServiceProvider } from "@proto-kit/protocol";
+import { container } from "tsyringe";
+import { InMemoryStateService, Runtime } from "../src";
+export function createTestingRuntime(modules, config) {
+    const state = new InMemoryStateService();
+    const Runtimeclass = Runtime.from({
+        modules,
+    });
+    const runtime = new Runtimeclass();
+    runtime.configure(config);
+    runtime.create(() => container.createChildContainer());
+    runtime.dependencyContainer.register("AreProofsEnabled", {
+        useValue: {
+            areProofsEnabled: false,
+            setProofsEnabled(areProofsEnabled) {
+                this.areProofsEnabled = areProofsEnabled;
+            },
+        },
+    });
+    runtime.registerValue({
+        StateServiceProvider: new StateServiceProvider(),
+        Runtime: runtime,
+    });
+    runtime.stateServiceProvider.setCurrentStateService(state);
+    return {
+        runtime,
+        state,
+    };
+}

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

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+//# sourceMappingURL=runtimeMethod.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeMethod.test.d.ts","sourceRoot":"","sources":["../../../test/method/runtimeMethod.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/test/method/runtimeMethod.test.js

@@ -0,0 +1,30 @@
+import "reflect-metadata";
+import { Bool, Field } from "o1js";
+import { Option, StateTransition } from "@proto-kit/protocol";
+import { toStateTransitionsHash } from "../../src/method/runtimeMethod";
+describe.skip("toStateTransitionsHash", () => {
+    const noneStateTransition = StateTransition.from(Field(0), new Option(Bool(false), Field(0), Field));
+    const someStateTransition = StateTransition.from(Field(0), new Option(Bool(true), Field(0), Field));
+    it.each([
+        [
+            [noneStateTransition],
+            "7067243248312463521220230733411703436580237248681301130001246160136823979683",
+        ],
+        [
+            [someStateTransition],
+            "12841542804403638489097503092490970035615082088155587790175618374946575398395",
+        ],
+        [
+            [noneStateTransition, someStateTransition],
+            "20641278138648130746922286021889771603940136555847557324578879341962747943601",
+        ],
+        [
+            [someStateTransition, noneStateTransition],
+            "10362098987098600767020985423446775093761176563902435645494178193997179006954",
+        ],
+    ])("should calculate a hash of all provided state transitions", (stateTransitions, expectedHash) => {
+        expect.assertions(1);
+        const hash = toStateTransitionsHash(stateTransitions).toString();
+        expect(hash).toBe(expectedHash);
+    });
+});