@proto-kit/module 0.1.1-develop.153

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EAGf,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAcjE,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,mDAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,kBAAkB,CAAC;AAEvE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,iBAoC9C;AAED,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,MAAM,UAGnB;AAED,eAAO,MAAM,wBAAwB,eAAe,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,wBAAgB,aAAa,aAEjB,cAAc,OAAO,CAAC,cAClB,MAAM,cACN,kBAAkB,UA2EjC"}

package/dist/method/runtimeMethod.js

@@ -0,0 +1,114 @@
+import { container } from "tsyringe";
+import { DefaultProvableHashList, ProvableStateTransition, MethodPublicOutput, } from "@proto-kit/protocol";
+import { toProver } from "@proto-kit/common";
+import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext.js";
+const errors = {
+    runtimeNotProvided: (name) => new Error(`Runtime was not provided for module: ${name}`),
+    methodInputsNotProvided: () => new Error("Method execution inputs not provided, provide them via context.inputs"),
+};
+export function toStateTransitionsHash(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+stateTransitions) {
+    const stateTransitionsHashList = new DefaultProvableHashList(ProvableStateTransition);
+    return stateTransitions
+        .map((stateTransition) => stateTransition.toProvable())
+        .reduce((allStateTransitionsHashList, stateTransition) => allStateTransitionsHashList.push(stateTransition), stateTransitionsHashList)
+        .toField();
+}
+export function toWrappedMethod(methodName, moduleMethod) {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+    const wrappedMethod = (...args) => {
+        Reflect.apply(moduleMethod, this, args);
+        const { result: { stateTransitions, status }, input, } = executionContext.current();
+        const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
+        if (input === undefined) {
+            throw errors.methodInputsNotProvided();
+        }
+        const transactionHash = input.transaction.hash();
+        const networkStateHash = input.networkState.hash();
+        return new MethodPublicOutput({
+            stateTransitionsHash,
+            status,
+            transactionHash,
+            networkStateHash,
+        });
+    };
+    Object.defineProperty(wrappedMethod, "name", {
+        value: `wrapped_${methodName}`,
+        writable: false,
+    });
+    return wrappedMethod;
+}
+export function combineMethodName(runtimeModuleName, methodName) {
+    return `${runtimeModuleName}.${methodName}`;
+}
+export const runtimeMethodMetadataKey = "yab-method";
+/**
+ * Checks the metadata of the provided runtime module and its method,
+ * to see if it has been decorated with @runtimeMethod()
+ *
+ * @param target - Runtime module to check
+ * @param propertyKey - Name of the method to check in the prior runtime module
+ * @returns - If the provided method name is a runtime method or not
+ */
+export function isRuntimeMethod(target, propertyKey) {
+    return Boolean(Reflect.getMetadata(runtimeMethodMetadataKey, target, propertyKey));
+}
+export function runtimeMethod() {
+    return (target, methodName, descriptor) => {
+        const executionContext = container.resolve(RuntimeMethodExecutionContext);
+        Reflect.defineMetadata(runtimeMethodMetadataKey, true, 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;
+            /**
+             * If its a top level method call, wrap it into a wrapped method,
+             * since it'll be turned into a real/mock prover in provableMethod().
+             *
+             * Otherwise provableMethod() will just call the originalMethod provided
+             * if method is not called at the top level.
+             */
+            const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
+                methodName,
+                simulatedMethod,
+            ]);
+            /**
+             * Before the prover runs, make sure it is operating on the correct
+             * 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
+                    result = await Reflect.apply(innerProver, this, args);
+                }
+                finally {
+                    executionContext.afterMethod();
+                }
+                return result;
+            }
+            executionContext.beforeMethod(constructorName, methodName, args);
+            if (executionContext.isTopLevel) {
+                if (!this.runtime) {
+                    throw errors.runtimeNotProvided(constructorName);
+                }
+                executionContext.setProver(prover.bind(this.runtime.zkProgrammable));
+            }
+            // eslint-disable-next-line @typescript-eslint/init-declarations
+            let result;
+            try {
+                result = Reflect.apply(simulatedMethod, this, args);
+            }
+            finally {
+                executionContext.afterMethod();
+            }
+            return result;
+        };
+    };
+}

package/dist/module/decorator.d.ts

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

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

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

package/dist/module/decorator.js

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

package/dist/runtime/Runtime.d.ts

@@ -0,0 +1,71 @@
+import { Experimental } from "snarkyjs";
+import { DependencyContainer } from "tsyringe";
+import { StringKeyOf, ModuleContainer, ModulesConfig, ModulesRecord, TypedClass, ZkProgrammable, PlainZkProgram, WithZkProgrammable, AreProofsEnabled } from "@proto-kit/common";
+import { MethodPublicOutput } from "@proto-kit/protocol";
+import { StateService } from "../state/InMemoryStateService.js";
+import { StateServiceProvider } from "../state/StateServiceProvider";
+import { RuntimeModule } from "./RuntimeModule.js";
+/**
+ * Record of modules accepted by the Runtime module container.
+ *
+ * We have to use TypedClass since RuntimeModule
+ * is an abstract class
+ */
+export type RuntimeModulesRecord = ModulesRecord<TypedClass<RuntimeModule<unknown>>>;
+/**
+ * Definition / required arguments for the Runtime class
+ */
+export interface RuntimeDefinition<Modules extends RuntimeModulesRecord> {
+    state: StateService;
+    modules: Modules;
+    config?: ModulesConfig<Modules>;
+}
+export declare class RuntimeZkProgrammable<Modules extends RuntimeModulesRecord> extends ZkProgrammable<undefined, MethodPublicOutput> {
+    runtime: Runtime<Modules>;
+    constructor(runtime: Runtime<Modules>);
+    get appChain(): AreProofsEnabled | undefined;
+    zkProgramFactory(): PlainZkProgram<undefined, MethodPublicOutput>;
+}
+/**
+ * Wrapper for an application specific runtime, which helps orchestrate
+ * runtime modules into an interoperable runtime.
+ */
+export declare class Runtime<Modules extends RuntimeModulesRecord> extends ModuleContainer<Modules> implements WithZkProgrammable<undefined, MethodPublicOutput> {
+    static from<Modules extends RuntimeModulesRecord>(definition: RuntimeDefinition<Modules>): Runtime<Modules>;
+    program?: ReturnType<typeof Experimental.ZkProgram>;
+    definition: RuntimeDefinition<Modules>;
+    zkProgrammable: ZkProgrammable<undefined, MethodPublicOutput>;
+    private readonly stateServiceProviderInstance;
+    /**
+     * Creates a new Runtime from the provided config
+     *
+     * @param modules - Configuration object for the constructed Runtime
+     */
+    constructor(definition: RuntimeDefinition<Modules>);
+    get appChain(): AreProofsEnabled | undefined;
+    get stateService(): StateService;
+    get stateServiceProvider(): StateServiceProvider;
+    /**
+     * @returns The dependency injection container of this runtime
+     */
+    get dependencyContainer(): DependencyContainer;
+    /**
+     * @param methodId The encoded name of the method to call.
+     * Encoding: "stringToField(module.name) << 128 + stringToField(method-name)"
+     */
+    getMethodById(methodId: bigint): (...args: unknown[]) => unknown;
+    getMethodNameFromId(methodId: bigint): [string, string];
+    getMethodId(moduleName: string, methodName: string): bigint;
+    /**
+     * Add a name and other respective properties required by RuntimeModules,
+     * that come from the current Runtime
+     *
+     * @param name - Name of the runtime module to decorate
+     */
+    decorateModule(moduleName: StringKeyOf<Modules>, containedModule: InstanceType<Modules[StringKeyOf<Modules>]>): void;
+    /**
+     * @returns A list of names of all the registered module names
+     */
+    get runtimeModuleNames(): string[];
+}
+//# sourceMappingURL=Runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/Runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAc,MAAM,UAAU,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAQ7B,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAErE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;;;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,KAAK,EAAE,YAAY,CAAC;IACpB,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,CAAC,SAAS,EAAE,kBAAkB,CAAC;WAE9C,IAAI,CAAC,OAAO,SAAS,oBAAoB,EACrD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAMjC,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;IAIrE,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAE3C;IAEF;;;;OAIG;gBACgB,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IASzD,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAED,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAEtD;IAED;;OAEG;IACH,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED;;;OAGG;IACI,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO;IAiBhE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IASvD,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAQlE;;;;;OAKG;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

@@ -0,0 +1,185 @@
+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-next-line max-len
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment */
+import { Experimental } from "snarkyjs";
+import { injectable } from "tsyringe";
+import { ModuleContainer, ZkProgrammable, } from "@proto-kit/common";
+import { fieldToString, stringToField, MethodPublicOutput, } from "@proto-kit/protocol";
+import { combineMethodName, isRuntimeMethod, toWrappedMethod, } from "../method/runtimeMethod.js";
+import { StateServiceProvider } from "../state/StateServiceProvider";
+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;
+    }
+    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 max-len
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define,prefer-destructuring,putout/putout
+        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 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 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
+                    // TODO: find out how to import the Tuple type
+                    const privateInputs = Reflect.getMetadata("design:paramtypes", runtimeModule, methodName);
+                    return {
+                        ...allModuleMethods,
+                        [combinedMethodName]: {
+                            privateInputs,
+                            method: wrappedMethod,
+                        },
+                    };
+                }
+                return allModuleMethods;
+            }, {});
+            return {
+                ...allMethods,
+                ...moduleMethods,
+            };
+        }, {});
+        const sortedRuntimeMethods = Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
+        Object.entries(runtimeMethods).sort());
+        const program = Experimental.ZkProgram({
+            publicOutput: MethodPublicOutput,
+            methods: sortedRuntimeMethods,
+        });
+        const SelfProof = Experimental.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),
+            Proof: SelfProof,
+            methods,
+        };
+    }
+}
+/**
+ * Wrapper for an application specific runtime, which helps orchestrate
+ * runtime modules into an interoperable runtime.
+ */
+let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
+    static from(definition) {
+        return new Runtime_1(definition);
+    }
+    /**
+     * Creates a new Runtime from the provided config
+     *
+     * @param modules - Configuration object for the constructed Runtime
+     */
+    constructor(definition) {
+        super(definition);
+        // eslint-disable-next-line no-warning-comments
+        // TODO DI
+        this.stateServiceProviderInstance = new StateServiceProvider(this.definition.state);
+        this.definition = definition;
+        this.zkProgrammable = new RuntimeZkProgrammable(this);
+        // this.registerValue({
+        //   Runtime: this,
+        // });
+    }
+    get appChain() {
+        return this.container.resolve("AppChain");
+    }
+    get stateService() {
+        return this.stateServiceProviderInstance.stateService;
+    }
+    get stateServiceProvider() {
+        return this.stateServiceProviderInstance;
+    }
+    /**
+     * @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 [moduleName, methodName] = this.getMethodNameFromId(methodId);
+        this.isValidModuleName(this.definition.modules, 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
+        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);
+    }
+    getMethodNameFromId(methodId) {
+        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+        const moduleName = fieldToString(methodId >> 128n);
+        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+        const methodName = fieldToString(methodId % 2n ** 128n);
+        return [moduleName, methodName];
+    }
+    getMethodId(moduleName, methodName) {
+        return (
+        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+        (stringToField(moduleName).toBigInt() << 128n) +
+            stringToField(methodName).toBigInt());
+    }
+    /**
+     * Add a name and other respective properties required by RuntimeModules,
+     * that come from the current Runtime
+     *
+     * @param name - Name of the runtime module to decorate
+     */
+    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);
+export { Runtime };

package/dist/runtime/RuntimeModule.d.ts

@@ -0,0 +1,30 @@
+import { ConfigurableModule, Presets } from "@proto-kit/common";
+import { NetworkState, RuntimeTransaction } from "@proto-kit/protocol";
+import { StateService } from "../state/InMemoryStateService";
+import type { Runtime, RuntimeDefinition, RuntimeModulesRecord } from "./Runtime";
+/**
+ * This type exists to carry over certain runtime properties
+ * to runtime modules, until we can inject them through DI.
+ */
+export interface PartialRuntime extends Pick<Runtime<RuntimeModulesRecord>, "zkProgrammable"> {
+    definition: Pick<RuntimeDefinition<RuntimeModulesRecord>, "state">;
+    get stateService(): StateService;
+}
+/**
+ * Base class for runtime modules providing the necessary utilities.
+ */
+export declare class RuntimeModule<Config> extends ConfigurableModule<Config> {
+    static presets: Presets<unknown>;
+    /**
+     * 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?: Runtime<RuntimeModulesRecord>;
+    private getInputs;
+    get transaction(): RuntimeTransaction;
+    get network(): NetworkState;
+}
+//# sourceMappingURL=RuntimeModule.d.ts.map

package/dist/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,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAMvE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EACV,OAAO,EACP,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,WAAW,CAAC;AAMnB;;;GAGG;AACH,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,gBAAgB,CAAC;IAC7D,UAAU,EAAE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC,CAAC;IAEnE,IAAI,YAAY,IAAI,YAAY,CAAC;CAClC;AAED;;GAEG;AACH,qBACa,aAAa,CAAC,MAAM,CAAE,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IACnE,OAAc,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAM;IAE7C;;;;OAIG;IACI,eAAe,UAAQ;IAEvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE/C,OAAO,CAAC,SAAS;IAWjB,IAAW,WAAW,IAAI,kBAAkB,CAE3C;IAED,IAAW,OAAO,IAAI,YAAY,CAEjC;CACF"}

package/dist/runtime/RuntimeModule.js

@@ -0,0 +1,44 @@
+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;
+};
+import { ConfigurableModule } from "@proto-kit/common";
+import { container, injectable } from "tsyringe";
+import { RuntimeMethodExecutionContext, } from "../method/RuntimeMethodExecutionContext";
+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 {
+    constructor() {
+        super(...arguments);
+        /**
+         * 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.
+         */
+        this.isRuntimeModule = true;
+    }
+    getInputs() {
+        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;
+    }
+};
+RuntimeModule.presets = {};
+RuntimeModule = __decorate([
+    injectable()
+], RuntimeModule);
+export { RuntimeModule };

package/dist/state/InMemoryStateService.d.ts

@@ -0,0 +1,14 @@
+import { Field } from "snarkyjs";
+export interface StateService {
+    get: (key: Field) => Field[] | undefined;
+    set: (key: Field, value: Field[] | undefined) => void;
+}
+/**
+ * Naive implementation of a StateService for testing purposes
+ */
+export declare class InMemoryStateService implements StateService {
+    values: Record<string, Field[] | undefined>;
+    get(key: Field): Field[] | undefined;
+    set(key: Field, value: Field[] | undefined): void;
+}
+//# sourceMappingURL=InMemoryStateService.d.ts.map

package/dist/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,UAAU,CAAC;AAEjC,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,KAAK,EAAE,GAAG,SAAS,CAAC;IACzC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,SAAS,KAAK,IAAI,CAAC;CACvD;AAED;;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"}

package/dist/state/InMemoryStateService.js

@@ -0,0 +1,21 @@
+/**
+ * Naive implementation of a StateService for testing purposes
+ */
+export class InMemoryStateService {
+    constructor() {
+        this.values = {};
+    }
+    get(key) {
+        return this.values[key.toString()];
+    }
+    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()];
+        }
+        else {
+            this.values[key.toString()] = value;
+        }
+    }
+}

package/dist/state/State.d.ts

@@ -0,0 +1,65 @@
+import { Field, type FlexibleProvablePure } from "snarkyjs";
+import { Option, type Path } from "@proto-kit/protocol";
+import { PartialRuntime } from "../runtime/RuntimeModule.js";
+export declare class WithPath {
+    path?: Field;
+    hasPathOrFail(): asserts this is {
+        path: Path;
+    };
+}
+export declare class WithRuntime {
+    runtime?: PartialRuntime;
+    hasRuntimeOrFail(): asserts this is {
+        runtime: PartialRuntime;
+    };
+}
+declare const State_base: import("ts-mixer/dist/types/types.js").Class<any[], WithPath & WithRuntime, typeof WithPath & typeof WithRuntime, false>;
+/**
+ * Utilities for runtime module state, such as get/set
+ */
+export declare class State<Value> extends State_base {
+    valueType: FlexibleProvablePure<Value>;
+    /**
+     * Creates a new state wrapper for the provided value type.
+     *
+     * @param valueType - Type of value to be stored (e.g. UInt64, Struct, ...)
+     * @returns New state for the given value type.
+     */
+    static from<Value>(valueType: FlexibleProvablePure<Value>): State<Value>;
+    /**
+     * Computes a dummy value for the given value type.
+     *
+     * @param valueType - Value type to generate the dummy value for
+     * @returns Dummy value for the given value type
+     */
+    static dummyValue<Value>(valueType: FlexibleProvablePure<Value>): Value;
+    constructor(valueType: FlexibleProvablePure<Value>);
+    /**
+     * Provides an in-circuit witness for the current state representation,
+     * and constructs an Option out of it.
+     *
+     * @returns Optional value of the current state
+     */
+    private witnessState;
+    /**
+     * Retrieves the current state and creates a state transition
+     * anchoring the use of the current state value in the circuit.
+     *
+     * @returns Option representation of the current state.
+     */
+    get(): Option<Value>;
+    /**
+     * Sets a new state value by creating a state transition from
+     * the current value to the newly set value.
+     *
+     * The newly set value isn't available via state.get(), since the
+     * state transitions are not applied within the same circuit.
+     * You can however store and access your new value in
+     * a separate circuit variable.
+     *
+     * @param value - Value to be set as the current state
+     */
+    set(value: Value): void;
+}
+export {};
+//# sourceMappingURL=State.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../src/state/State.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,EAAY,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAE5E,OAAO,EAAE,MAAM,EAAmB,KAAK,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEzE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAG7D,qBAAa,QAAQ;IACZ,IAAI,CAAC,EAAE,KAAK,CAAC;IAEb,aAAa,IAAI,OAAO,CAAC,IAAI,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;CAOvD;AAED,qBAAa,WAAW;IACf,OAAO,CAAC,EAAE,cAAc,CAAC;IAEzB,gBAAgB,IAAI,OAAO,CAAC,IAAI,IAAI;QACzC,OAAO,EAAE,cAAc,CAAC;KACzB;CAOF;;AAED;;GAEG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,UAA4B;IA2BlC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IA1BhE;;;;;OAKG;WACW,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAIhE;;;;;OAKG;WACW,UAAU,CAAC,KAAK,EAC5B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,GACrC,KAAK;gBAQkB,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAIhE;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IA6BpB;;;;;OAKG;IACI,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;IAc3B;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,KAAK;CAiBxB"}