@proto-kit/module 0.1.1-develop.245 → 0.1.1-develop.254

package/dist/module/src/method/MethodParameterDecoder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MethodParameterDecoder.d.ts","sourceRoot":"","sources":["../../../../src/method/MethodParameterDecoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,KAAK,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAC7B,UAAU,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,SAAS,CAAC;IAC3C,IAAI,EAAE,MAAM,CAAC;IAEb,SAAS,EAAE;QACT,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;KACjB,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAYD,qBAAa,sBAAsB;IAWb,OAAO,CAAC,QAAQ,CAAC,KAAK;WAV5B,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,MAAM;IAU3E,OAAO;IAEA,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE;IAmB/C,IAAW,SAAS,IAAI,MAAM,CAM7B;CACF"}

package/dist/module/src/method/MethodParameterDecoder.js

@@ -1,33 +0,0 @@
-const errors = {
-    fieldLengthNotMatching: (expected, actual) => new Error(`Expected ${expected} field elements, got ${actual}`),
-    typeNotCompatible: (name) => new Error(`Cannot decode type ${name}, it has to be either a Struct, CircuitValue or built-in snarkyjs type`),
-};
-export class MethodParameterDecoder {
-    static fromMethod(target, methodName) {
-        const paramtypes = Reflect.getMetadata("design:paramtypes", target, methodName);
-        return new MethodParameterDecoder(paramtypes);
-    }
-    constructor(types) {
-        this.types = types;
-    }
-    fromFields(fields) {
-        if (fields.length < this.fieldSize) {
-            throw errors.fieldLengthNotMatching(this.fieldSize, fields.length);
-        }
-        let stack = fields.slice();
-        return this.types.map((type) => {
-            const numberFieldsNeeded = type.prototype._fields?.length ?? type.sizeInFields?.() ?? -1;
-            if (numberFieldsNeeded === -1) {
-                throw errors.typeNotCompatible(type.name);
-            }
-            const structFields = stack.slice(0, numberFieldsNeeded);
-            stack = stack.slice(numberFieldsNeeded);
-            return type.fromFields(structFields);
-        });
-    }
-    get fieldSize() {
-        return this.types
-            .map((type) => type.prototype._fields?.length ?? type.sizeInFields?.() ?? 0)
-            .reduce((a, b) => a + b, 0);
-    }
-}

package/dist/module/src/method/runtimeMethod.d.ts

@@ -1,19 +0,0 @@
-import { StateTransition, MethodPublicOutput } from "@proto-kit/protocol";
-import type { RuntimeModule } from "../runtime/RuntimeModule.js";
-export declare function toStateTransitionsHash(stateTransitions: StateTransition<any>[]): import("snarkyjs/dist/node/lib/field.js").Field;
-export type WrappedMethod = (...args: unknown[]) => MethodPublicOutput;
-export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: unknown[]) => unknown): WrappedMethod;
-export declare function combineMethodName(runtimeModuleName: string, methodName: string): string;
-export declare const runtimeMethodMetadataKey = "yab-method";
-export declare const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
-/**
- * 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 declare function isRuntimeMethod(target: RuntimeModule<unknown>, propertyKey: string): boolean;
-export declare function runtimeMethod(): (target: RuntimeModule<unknown>, methodName: string, descriptor: PropertyDescriptor) => void;
-//# sourceMappingURL=runtimeMethod.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EAGf,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAYjE,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;AACrD,eAAO,MAAM,6BAA6B,8BAA8B,CAAC;AAEzE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,wBAAgB,aAAa,aAEjB,cAAc,OAAO,CAAC,cAClB,MAAM,cACN,kBAAkB,UAuFjC"}

package/dist/module/src/method/runtimeMethod.js

@@ -1,123 +0,0 @@
-import { container } from "tsyringe";
-import { DefaultProvableHashList, ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext } from "@proto-kit/protocol";
-import { toProver } from "@proto-kit/common";
-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";
-export const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";
-/**
- * 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);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        let data = Reflect.getMetadata(runtimeMethodNamesMetadataKey, target);
-        if (data !== undefined) {
-            data.push(methodName);
-        }
-        else {
-            data = [methodName];
-        }
-        Reflect.defineMetadata(runtimeMethodNamesMetadataKey, data, target);
-        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/src/module/decorator.d.ts

@@ -1,8 +0,0 @@
-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/src/module/decorator.d.ts.map

@@ -1 +0,0 @@
-{"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/src/module/decorator.js

@@ -1,15 +0,0 @@
-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/module/src/runtime/MethodIdResolver.d.ts

@@ -1,18 +0,0 @@
-import type { Runtime, RuntimeModulesRecord } from "./Runtime";
-/**
- * How do we encode MethodIds
- * A MethodId is defined as the following in little-endian
- * [0
- *   ...hash(stringToField(moduleName))[0..128],
- *   ...hash(stringToField(methodName))[0..128]
- * ]
- */
-export declare class MethodIdResolver {
-    private readonly runtime;
-    private readonly modules;
-    private readonly dictionary;
-    constructor(runtime: Runtime<RuntimeModulesRecord>, modules: RuntimeModulesRecord);
-    getMethodNameFromId(methodId: bigint): [string, string] | undefined;
-    getMethodId(moduleName: string, methodName: string): bigint;
-}
-//# sourceMappingURL=MethodIdResolver.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"MethodIdResolver.d.ts","sourceRoot":"","sources":["../../../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAM/D;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAIzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;gBAGzC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,EACtC,OAAO,EAAE,oBAAoB;IAmBzC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAsBnE,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAQnE"}

package/dist/module/src/runtime/MethodIdResolver.js

@@ -1,50 +0,0 @@
-import { singleFieldToString, stringToField } from "@proto-kit/protocol";
-const offset = 128n;
-// eslint-disable-next-line @typescript-eslint/no-magic-numbers
-const modulus = 2n ** (offset - 1n);
-/**
- * How do we encode MethodIds
- * A MethodId is defined as the following in little-endian
- * [0
- *   ...hash(stringToField(moduleName))[0..128],
- *   ...hash(stringToField(methodName))[0..128]
- * ]
- */
-export class MethodIdResolver {
-    constructor(runtime, modules) {
-        this.runtime = runtime;
-        this.modules = modules;
-        this.dictionary = {};
-        this.dictionary = runtime.runtimeModuleNames.reduce((dict, moduleName) => {
-            this.runtime.assertIsValidModuleName(modules, moduleName);
-            dict[(stringToField(moduleName).toBigInt() % modulus).toString()] =
-                moduleName;
-            runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
-                dict[(stringToField(methodName).toBigInt() % modulus).toString()] =
-                    methodName;
-            });
-            return dict;
-        }, {});
-    }
-    getMethodNameFromId(methodId) {
-        const moduleNameHash = singleFieldToString(methodId >> offset);
-        const methodNameHash = singleFieldToString(methodId % modulus);
-        const moduleName = this.dictionary[moduleNameHash];
-        // eslint-disable-next-line no-warning-comments
-        // TODO Replace by throwing exception?
-        if (moduleName === undefined) {
-            return undefined;
-        }
-        this.runtime.assertIsValidModuleName(this.modules, moduleName);
-        const methodName = this.dictionary[methodNameHash];
-        if (methodName === undefined) {
-            return undefined;
-        }
-        return [moduleName, methodName];
-    }
-    getMethodId(moduleName, methodName) {
-        this.runtime.assertIsValidModuleName(this.modules, moduleName);
-        return ((stringToField(moduleName).toBigInt() % modulus << offset) +
-            (stringToField(methodName).toBigInt() % modulus));
-    }
-}

package/dist/module/src/runtime/Runtime.d.ts

@@ -1,72 +0,0 @@
-import { Experimental } from "snarkyjs";
-import { DependencyContainer } from "tsyringe";
-import { StringKeyOf, ModuleContainer, ModulesConfig, ModulesRecord, TypedClass, ZkProgrammable, PlainZkProgram, WithZkProgrammable, AreProofsEnabled } from "@proto-kit/common";
-import { MethodPublicOutput, StateServiceProvider, StateService } from "@proto-kit/protocol";
-import { RuntimeModule } from "./RuntimeModule";
-/**
- * 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> {
-    /**
-     * @deprecated
-     */
-    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>);
-    start(): void;
-    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) | undefined;
-    /**
-     * 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: 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/module/src/runtime/Runtime.d.ts.map

@@ -1 +0,0 @@
-{"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,EACL,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACb,MAAM,qBAAqB,CAAC;AAU7B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;;;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;;OAEG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,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;IAErE,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAG3C;IAEF;;;;OAIG;gBACgB,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAQlD,KAAK;IAOZ,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,CAClB,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS;IAwBhD;;;;;;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/module/src/runtime/Runtime.js

@@ -1,184 +0,0 @@
-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,max-lines */
-import { Experimental } from "snarkyjs";
-import { injectable } from "tsyringe";
-import { ModuleContainer, ZkProgrammable, } from "@proto-kit/common";
-import { MethodPublicOutput, StateServiceProvider, } from "@proto-kit/protocol";
-import { combineMethodName, isRuntimeMethod, toWrappedMethod, } from "../method/runtimeMethod";
-import { MethodIdFactory } from "../factories/MethodIdFactory";
-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);
-        this.stateServiceProviderInstance = new StateServiceProvider(
-        // eslint-disable-next-line etc/no-deprecated
-        this.definition.state);
-        this.definition = definition;
-        this.zkProgrammable = new RuntimeZkProgrammable(this);
-    }
-    // eslint-disable-next-line no-warning-comments
-    // TODO Remove after changing DFs to type-based approach
-    start() {
-        this.registerValue({
-            Runtime: this,
-        });
-        this.registerDependencyFactories([MethodIdFactory]);
-    }
-    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 methodDescriptor = this.container
-            .resolve("MethodIdResolver")
-            .getMethodNameFromId(methodId);
-        if (methodDescriptor === undefined) {
-            return undefined;
-        }
-        const [moduleName, methodName] = methodDescriptor;
-        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);
-    }
-    /**
-     * 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);
-export { Runtime };

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

@@ -1,34 +0,0 @@
-import { ConfigurableModule, Presets } from "@proto-kit/common";
-import { NetworkState, RuntimeTransaction, StateService } from "@proto-kit/protocol";
-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>;
-    /**
-     * 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?: Runtime<RuntimeModulesRecord>;
-    constructor();
-    private getInputs;
-    get transaction(): RuntimeTransaction;
-    get network(): NetworkState;
-}
-//# sourceMappingURL=RuntimeModule.d.ts.map

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

@@ -1 +0,0 @@
-{"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,EACL,YAAY,EACZ,kBAAkB,EAClB,YAAY,EAGb,MAAM,qBAAqB,CAAC;AAI7B,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;;OAEG;IACH,SAAgB,kBAAkB,EAAE,MAAM,EAAE,CAAM;IAElD;;;;OAIG;IACI,eAAe,UAAQ;IAEvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;;IAY/C,OAAO,CAAC,SAAS;IAWjB,IAAW,WAAW,IAAI,kBAAkB,CAE3C;IAED,IAAW,OAAO,IAAI,YAAY,CAEjC;CACF"}

package/dist/module/src/runtime/RuntimeModule.js

@@ -1,56 +0,0 @@
-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, } from "@proto-kit/protocol";
-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 {
-    constructor() {
-        super();
-        /**
-         * Holds all method names that are callable throw transactions
-         */
-        this.runtimeMethodNames = [];
-        /**
-         * 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;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const methodNames = Reflect.getMetadata(runtimeMethodNamesMetadataKey, this);
-        this.runtimeMethodNames = methodNames ?? [];
-    }
-    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(),
-    __metadata("design:paramtypes", [])
-], RuntimeModule);
-export { RuntimeModule };

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

@@ -1,11 +0,0 @@
-import { Field } from "snarkyjs";
-import { StateService } from "@proto-kit/protocol";
-/**
- * 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