@proto-kit/module 0.1.1-develop.0

package/dist/method/runtimeMethod.js

@@ -0,0 +1,169 @@
+import { Bool, Field, Poseidon } from "o1js";
+import { container } from "tsyringe";
+import { ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext, StateTransitionReductionList, DefaultProvableHashList, } from "@proto-kit/protocol";
+import { toProver, } from "@proto-kit/common";
+import { MethodParameterEncoder, checkArgsProvable, } from "./MethodParameterEncoder";
+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"),
+    runtimeNameNotSet: () => new Error("Runtime name was not set"),
+    fieldNotConstant: (name) => new Error(`In-circuit field ${name} not a constant, this is likely a framework bug`),
+};
+export function toStateTransitionsHash(stateTransitions) {
+    const stateTransitionsHashList = new StateTransitionReductionList(ProvableStateTransition);
+    return stateTransitions
+        .map((stateTransition) => stateTransition.toProvable())
+        .reduce((allStateTransitionsHashList, stateTransition) => allStateTransitionsHashList.push(stateTransition), stateTransitionsHashList)
+        .toField();
+}
+export function toEventsHash(events) {
+    return events.reduce((acc, event) => {
+        const hashList = new DefaultProvableHashList(event.eventType, acc);
+        hashList.pushIf(event.event, event.condition);
+        return hashList.commitment;
+    }, Field(0));
+}
+export function toWrappedMethod(methodName, moduleMethod, options) {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+    const wrappedMethod = async (...args) => {
+        await Reflect.apply(moduleMethod, this, args);
+        const { result: { stateTransitions, status, events }, } = executionContext.current();
+        const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
+        const eventsHash = toEventsHash(events);
+        const { name, runtime } = this;
+        if (name === undefined) {
+            throw errors.runtimeNameNotSet();
+        }
+        if (runtime === undefined) {
+            throw errors.runtimeNotProvided(name);
+        }
+        const { transaction, networkState } = executionContext.witnessInput();
+        const { methodIdResolver } = runtime;
+        // Assert that the given transaction has the correct methodId
+        const thisMethodId = Field(methodIdResolver.getMethodId(name, methodName));
+        if (!thisMethodId.isConstant()) {
+            throw errors.fieldNotConstant("methodId");
+        }
+        transaction.methodId.assertEquals(thisMethodId, "Runtimemethod called with wrong methodId on the transaction object");
+        /**
+         * Use the type info obtained previously to convert
+         * the args passed to fields
+         */
+        const { fields } = MethodParameterEncoder.fromMethod(this, methodName).encode(args);
+        // Assert that the argsHash that has been signed matches the given arguments
+        const argsHash = Poseidon.hash(fields);
+        transaction.argsHash.assertEquals(argsHash, "argsHash and therefore arguments of transaction and runtime call does not match");
+        const isMessage = Bool(options.invocationType === "INCOMING_MESSAGE");
+        transaction.assertTransactionType(Bool(isMessage));
+        const transactionHash = transaction.hash();
+        const networkStateHash = networkState.hash();
+        return new MethodPublicOutput({
+            stateTransitionsHash,
+            status,
+            transactionHash,
+            networkStateHash,
+            isMessage,
+            eventsHash,
+        });
+    };
+    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";
+export const runtimeMethodTypeMetadataKey = "proto-kit-runtime-method-type";
+/**
+ * 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));
+}
+function runtimeMethodInternal(options) {
+    return (target, methodName, descriptor) => {
+        checkArgsProvable(target, methodName);
+        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);
+        Reflect.defineMetadata(runtimeMethodTypeMetadataKey, options.invocationType, target, methodName);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const simulatedMethod = descriptor.value;
+        descriptor.value = async function value(...args) {
+            const constructorName = this.name;
+            /**
+             * If its a top level method call, wrap it into a wrapped method,
+             * since it'll be turned into a real/mock prover in provableMethod().
+             *
+             * 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,
+                options,
+            ]);
+            /**
+             * Before the prover runs, make sure it is operating on the correct
+             * RuntimeMethodExecutionContext state, meaning it enters and exits
+             * the context properly.
+             */
+            async function prover() {
+                executionContext.beforeMethod(constructorName, methodName, args);
+                const innerProver = toProver(combineMethodName(constructorName, methodName), simulatedWrappedMethod, false, ...args).bind(this);
+                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));
+            }
+            let result;
+            try {
+                result = await Reflect.apply(simulatedMethod, this, args);
+            }
+            finally {
+                executionContext.afterMethod();
+            }
+            return result;
+        };
+    };
+}
+export function runtimeMessage() {
+    return runtimeMethodInternal({
+        invocationType: "INCOMING_MESSAGE",
+    });
+}
+export function runtimeMethod() {
+    return runtimeMethodInternal({
+        invocationType: "SIGNATURE",
+    });
+}
+//# sourceMappingURL=runtimeMethod.js.map

package/dist/method/runtimeMethod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeMethod.js","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"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"}

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,16 @@
+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);
+    };
+}
+//# sourceMappingURL=decorator.js.map

package/dist/module/decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.js","sourceRoot":"","sources":["../../src/module/decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAKtC;;;GAGG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO;IACL;;;OAGG;IACH,MACoC,EACpC,EAAE;QACF,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC;IACvB,CAAC,CAAC;AACJ,CAAC"}

package/dist/runtime/MethodIdResolver.d.ts

@@ -0,0 +1,20 @@
+import { RuntimeMethodIdMapping } from "@proto-kit/protocol";
+import type { Runtime, RuntimeModulesRecord } from "./Runtime";
+/**
+ * Please see `getMethodId` to learn more about
+ * methodId encoding
+ */
+export declare class MethodIdResolver {
+    private readonly runtime;
+    private readonly dictionary;
+    constructor(runtime: Runtime<RuntimeModulesRecord>);
+    /**
+     * The purpose of this method is to provide a dictionary where
+     * we can look up properties like methodId and invocationType
+     * for each runtimeMethod using their module name and method name
+     */
+    methodIdMap(): RuntimeMethodIdMapping;
+    getMethodNameFromId(methodId: bigint): [string, string] | undefined;
+    getMethodId(moduleName: string, methodName: string): bigint;
+}
+//# sourceMappingURL=MethodIdResolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MethodIdResolver.d.ts","sourceRoot":"","sources":["../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAS5E,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAE/D;;;GAGG;AACH,qBACa,gBAAgB;IAMN,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAEpB;gBAG+B,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAkB5E;;;;OAIG;IACI,WAAW,IAAI,sBAAsB;IAuCrC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAcnE,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAQnE"}

package/dist/runtime/MethodIdResolver.js

@@ -0,0 +1,91 @@
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { filterNonUndefined } from "@proto-kit/common";
+import { stringToField } from "@proto-kit/protocol";
+import { Poseidon } from "o1js";
+import { inject, injectable } from "tsyringe";
+import { runtimeMethodTypeMetadataKey, } from "../method/runtimeMethod";
+/**
+ * Please see `getMethodId` to learn more about
+ * methodId encoding
+ */
+export let MethodIdResolver = class MethodIdResolver {
+    constructor(runtime) {
+        this.runtime = runtime;
+        this.dictionary = {};
+        this.dictionary = runtime.runtimeModuleNames.reduce((dict, moduleName) => {
+            this.runtime.assertIsValidModuleName(moduleName);
+            runtime.resolve(moduleName).runtimeMethodNames.forEach((methodName) => {
+                dict[this.getMethodId(moduleName, methodName).toString()] = {
+                    moduleName,
+                    methodName,
+                };
+            });
+            return dict;
+        }, {});
+    }
+    /**
+     * The purpose of this method is to provide a dictionary where
+     * we can look up properties like methodId and invocationType
+     * for each runtimeMethod using their module name and method name
+     */
+    methodIdMap() {
+        const methodIdResolver = this.runtime.dependencyContainer.resolve("MethodIdResolver");
+        const rawMappings = this.runtime.moduleNames.flatMap((moduleName) => {
+            const module = this.runtime.resolve(moduleName);
+            return module.runtimeMethodNames.map((method) => {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const type = Reflect.getMetadata(runtimeMethodTypeMetadataKey, module, method);
+                if (type !== undefined) {
+                    return {
+                        name: `${moduleName}.${method}`,
+                        methodId: methodIdResolver.getMethodId(moduleName, method),
+                        type,
+                    };
+                }
+                return undefined;
+            });
+        });
+        return rawMappings
+            .filter(filterNonUndefined)
+            .reduce((acc, entry) => {
+            acc[entry.name] = {
+                methodId: entry.methodId,
+                type: entry.type,
+            };
+            return acc;
+        }, {});
+    }
+    getMethodNameFromId(methodId) {
+        const methodPath = this.dictionary[methodId.toString()];
+        if (methodPath === undefined) {
+            return undefined;
+        }
+        const { moduleName, methodName } = methodPath;
+        this.runtime.assertIsValidModuleName(moduleName);
+        return [moduleName, methodName];
+    }
+    getMethodId(moduleName, methodName) {
+        this.runtime.assertIsValidModuleName(moduleName);
+        return Poseidon.hash([
+            stringToField(moduleName),
+            stringToField(methodName),
+        ]).toBigInt();
+    }
+};
+MethodIdResolver = __decorate([
+    injectable(),
+    __param(0, inject("Runtime")),
+    __metadata("design:paramtypes", [Function])
+], MethodIdResolver);
+//# sourceMappingURL=MethodIdResolver.js.map

package/dist/runtime/MethodIdResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodIdResolver.js","sourceRoot":"","sources":["../../src/runtime/MethodIdResolver.ts"],"names":[],"mappings":"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"}

package/dist/runtime/Runtime.d.ts

@@ -0,0 +1,72 @@
+import { ZkProgram } from "o1js";
+import { DependencyContainer } from "tsyringe";
+import { StringKeyOf, ModuleContainer, ModulesConfig, ModulesRecord, TypedClass, ZkProgrammable, PlainZkProgram, AreProofsEnabled, ChildContainerProvider, CompilableModule, CompileRegistry } from "@proto-kit/common";
+import { MethodPublicOutput, StateServiceProvider, SimpleAsyncStateService } from "@proto-kit/protocol";
+import { RuntimeModule } from "./RuntimeModule";
+import { MethodIdResolver } from "./MethodIdResolver";
+import { RuntimeEnvironment } from "./RuntimeEnvironment";
+export declare function getAllPropertyNames(obj: any): (string | symbol)[];
+/**
+ * Record of modules accepted by the Runtime module container.
+ *
+ * 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> {
+    modules: Modules;
+    config?: ModulesConfig<Modules>;
+}
+export declare class RuntimeZkProgrammable<Modules extends RuntimeModulesRecord> extends ZkProgrammable<undefined, MethodPublicOutput> {
+    runtime: Runtime<Modules>;
+    constructor(runtime: Runtime<Modules>);
+    get areProofsEnabled(): 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 RuntimeEnvironment, CompilableModule {
+    static from<Modules extends RuntimeModulesRecord>(definition: RuntimeDefinition<Modules>): TypedClass<Runtime<Modules>>;
+    program?: ReturnType<typeof ZkProgram>;
+    definition: RuntimeDefinition<Modules>;
+    zkProgrammable: ZkProgrammable<undefined, MethodPublicOutput>;
+    /**
+     * Creates a new Runtime from the provided config
+     *
+     * @param modules - Configuration object for the constructed Runtime
+     */
+    constructor(definition: RuntimeDefinition<Modules>);
+    create(childContainerProvider: ChildContainerProvider): void;
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    get stateServiceProvider(): StateServiceProvider;
+    get stateService(): SimpleAsyncStateService;
+    get methodIdResolver(): MethodIdResolver;
+    /**
+     * @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[]) => Promise<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[];
+    compile(registry: CompileRegistry): Promise<Record<string, import("@proto-kit/common").CompileArtifact>>;
+}
+//# 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":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,EAAa,mBAAmB,EAAc,MAAM,UAAU,CAAC;AACtE,OAAO,EACL,WAAW,EACX,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,uBAAuB,EAIxB,MAAM,qBAAqB,CAAC;AAW7B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,uBAa3C;AAED;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAC9C,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CACnC,CAAC;AAOF;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,oBAAoB;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,qBAAa,qBAAqB,CAChC,OAAO,SAAS,oBAAoB,CACpC,SAAQ,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;gBAAzB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;IAInD,IAAW,gBAAgB,iCAE1B;IAEM,gBAAgB,IAAI,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC,EAAE;CA+K3E;AAED;;;GAGG;AACH,qBACa,OAAO,CAAC,OAAO,SAAS,oBAAoB,CACvD,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,kBAAkB,EAAE,gBAAgB;WAEjC,IAAI,CAAC,OAAO,SAAS,oBAAoB,EACrD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACrC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IASxB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;IAEvC,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAEvC,cAAc,EAAE,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;IAErE;;;;OAIG;gBACgB,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAOlD,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;IAM5D,IAAW,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAE1D;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAItD;IAED,IAAW,YAAY,IAAI,uBAAuB,CAEjD;IAED,IAAW,gBAAgB,IAAI,gBAAgB,CAE9C;IAED;;OAEG;IACH,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED;;;OAGG;IACI,aAAa,CAClB,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS;IAsBzD;;;;;;OAMG;IACI,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAQ9D;;OAEG;IACH,IAAW,kBAAkB,aAE5B;IAEY,OAAO,CAAC,QAAQ,EAAE,eAAe;CAQ/C"}

package/dist/runtime/Runtime.js

@@ -0,0 +1,231 @@
+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 { container, injectable } from "tsyringe";
+import { ModuleContainer, ZkProgrammable, } from "@proto-kit/common";
+import { MethodPublicOutput, RuntimeMethodExecutionContext, RuntimeTransaction, NetworkState, } 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();
+        this.runtime = runtime;
+    }
+    get areProofsEnabled() {
+        return this.runtime.areProofsEnabled;
+    }
+    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 MAXIMUM_METHODS_PER_ZK_PROGRAM = 8;
+        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 }]);
+                    const privateInputs = Reflect.getMetadata("design:paramtypes", runtimeModule, methodName);
+                    return {
+                        ...allModuleMethods,
+                        [combinedMethodName]: {
+                            privateInputs,
+                            method: wrappedMethod,
+                        },
+                    };
+                }
+                return allModuleMethods;
+            }, {});
+            return {
+                ...allMethods,
+                ...moduleMethods,
+            };
+        }, {});
+        const sortedRuntimeMethods = Object.fromEntries(Object.entries(runtimeMethods).sort());
+        const splitRuntimeMethods = () => {
+            const buckets = [];
+            Object.entries(sortedRuntimeMethods).forEach(async ([methodName, method]) => {
+                let methodAdded = false;
+                for (const bucket of buckets) {
+                    if (buckets.length === 0) {
+                        const record = {};
+                        record[methodName] = method;
+                        buckets.push(record);
+                        methodAdded = true;
+                        break;
+                    }
+                    else if (Object.keys(bucket).length <=
+                        MAXIMUM_METHODS_PER_ZK_PROGRAM - 1) {
+                        bucket[methodName] = method;
+                        methodAdded = true;
+                        break;
+                    }
+                }
+                if (!methodAdded) {
+                    const record = {};
+                    record[methodName] = method;
+                    buckets.push(record);
+                }
+            });
+            return buckets;
+        };
+        return splitRuntimeMethods().map((bucket, index) => {
+            const name = `RuntimeProgram-${index}`;
+            const program = ZkProgram({
+                name,
+                publicOutput: MethodPublicOutput,
+                methods: bucket,
+            });
+            const SelfProof = ZkProgram.Proof(program);
+            const methods = Object.keys(bucket).reduce((boundMethods, methodName) => {
+                boundMethods[methodName] = program[methodName].bind(program);
+                return boundMethods;
+            }, {});
+            return {
+                name,
+                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);
+        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 areProofsEnabled() {
+        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);
+    }
+    async compile(registry) {
+        const context = container.resolve(RuntimeMethodExecutionContext);
+        context.setup({
+            transaction: RuntimeTransaction.dummyTransaction(),
+            networkState: NetworkState.empty(),
+        });
+        return await this.zkProgrammable.compile(registry);
+    }
+};
+Runtime = Runtime_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], Runtime);
+/* eslint-enable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument */
+//# sourceMappingURL=Runtime.js.map