@proto-kit/module 0.1.1-develop.153

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./method/RuntimeMethodExecutionContext";
+export * from "./method/assert";
+export * from "./method/runtimeMethod";
+export * from "./module/decorator";
+export * from "./runtime/RuntimeModule";
+export * from "./runtime/Runtime";
+export * from "./state/InMemoryStateService";
+export * from "./state/State";
+export * from "./state/StateMap";
+export * from "./state/StateServiceProvider";
+export * from "./state/decorator";
+export * from "./method/MethodParameterDecoder";

package/dist/method/MethodExecutionContext.d.ts

@@ -0,0 +1,73 @@
+import { Bool, type Proof } from "snarkyjs";
+import type { StateTransition, MethodPublicInput } from "@yab/protocol";
+export declare class MethodExecutionResult<ResultValue> {
+    stateTransitions: StateTransition<any>[];
+    status: Bool;
+    statusMessage?: string;
+    value?: ResultValue;
+    publicInput?: MethodPublicInput;
+    prove?: () => Promise<Proof<MethodPublicInput>>;
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+export declare class MethodExecutionContext<ResultValue> {
+    result: MethodExecutionResult<ResultValue>;
+    methods: string[];
+    constructor(result?: MethodExecutionResult<ResultValue>);
+    /**
+     * Adds an in-method generated state transition to the current context
+     * @param stateTransition - State transition to add to the context
+     */
+    addStateTransition<Value>(stateTransition: StateTransition<Value>): void;
+    /**
+     * @param message - Status message to acompany the current status
+     */
+    setStatusMessage(message?: string): void;
+    /**
+     * @param status - Execution status of the current method
+     */
+    setStatus(status: Bool): void;
+    /**
+     * @param value = Return value of the executed method
+     */
+    setValue(value: ResultValue): void;
+    /**
+     * Adds a method prover to the current execution context,
+     * which can be collected and ran asynchronously at a later point in time.
+     *
+     * @param prove - Prover function to be ran later,
+     * when the method execution needs to be proven
+     */
+    setProve(prove: () => Promise<Proof<MethodPublicInput>>): void;
+    setPublicInput(publicInput: MethodPublicInput): void;
+    /**
+     * Adds a method to the method execution stack, reseting the execution context
+     * in a case a new top-level (non nested) method call is made.
+     *
+     * @param methodName - Name of the method being captured in the context
+     */
+    beforeMethod(methodName: string): void;
+    /**
+     * Removes the latest method from the execution context stack,
+     * keeping track of the amount of 'unfinished' methods. Allowing
+     * for the context to distinguish between top-level and nested method calls.
+     */
+    afterMethod(): void;
+    get isTopLevel(): boolean;
+    get isFinished(): boolean;
+    /**
+     * @returns - Current execution context state
+     */
+    current(): {
+        isFinished: boolean;
+        result: MethodExecutionResult<ResultValue>;
+    };
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear(): void;
+}
+//# sourceMappingURL=MethodExecutionContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MethodExecutionContext.d.ts","sourceRoot":"","sources":["../../src/method/MethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAExE,qBAAa,qBAAqB,CAAC,WAAW;IAErC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;IAE9C,MAAM,EAAE,IAAI,CAAc;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,KAAK,CAAC,EAAE,WAAW,CAAC;IAEpB,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAEhC,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;CACxD;AAED;;;;GAIG;AACH,qBACa,sBAAsB,CAAC,WAAW;IAIpC,MAAM,EAAE,qBAAqB,CAAC,WAAW,CAAC;IAH5C,OAAO,EAAE,MAAM,EAAE,CAAM;gBAGrB,MAAM,GAAE,qBAAqB,CAAC,WAAW,CAA+B;IAGjF;;;OAGG;IACI,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;IAIxE;;OAEG;IACI,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM;IAIxC;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAI7B;;OAEG;IACI,QAAQ,CAAC,KAAK,EAAE,WAAW;IAIlC;;;;;;OAMG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAIvD,cAAc,CAAC,WAAW,EAAE,iBAAiB;IAEpD;;;;;OAKG;IACI,YAAY,CAAC,UAAU,EAAE,MAAM;IAOtC;;;;OAIG;IACI,WAAW;IAIlB,IAAW,UAAU,YAEpB;IAED,IAAW,UAAU,YAEpB;IAED;;OAEG;IACI,OAAO,IAAI;QAChB,UAAU,EAAE,OAAO,CAAC;QACpB,MAAM,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;KAC5C;IAOD;;OAEG;IACI,KAAK;CAGb"}

package/dist/method/MethodExecutionContext.js

@@ -0,0 +1,112 @@
+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 { Bool } from "snarkyjs";
+import { singleton } from "tsyringe";
+export class MethodExecutionResult {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.stateTransitions = [];
+        this.status = Bool(true);
+    }
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+let MethodExecutionContext = class MethodExecutionContext {
+    constructor(result = new MethodExecutionResult()) {
+        this.result = result;
+        this.methods = [];
+    }
+    /**
+     * Adds an in-method generated state transition to the current context
+     * @param stateTransition - State transition to add to the context
+     */
+    addStateTransition(stateTransition) {
+        this.result.stateTransitions.push(stateTransition);
+    }
+    /**
+     * @param message - Status message to acompany the current status
+     */
+    setStatusMessage(message) {
+        var _a;
+        (_a = this.result).statusMessage ?? (_a.statusMessage = message);
+    }
+    /**
+     * @param status - Execution status of the current method
+     */
+    setStatus(status) {
+        this.result.status = status;
+    }
+    /**
+     * @param value = Return value of the executed method
+     */
+    setValue(value) {
+        this.result.value = value;
+    }
+    /**
+     * Adds a method prover to the current execution context,
+     * which can be collected and ran asynchronously at a later point in time.
+     *
+     * @param prove - Prover function to be ran later,
+     * when the method execution needs to be proven
+     */
+    setProve(prove) {
+        this.result.prove = prove;
+    }
+    setPublicInput(publicInput) { }
+    /**
+     * Adds a method to the method execution stack, reseting the execution context
+     * in a case a new top-level (non nested) method call is made.
+     *
+     * @param methodName - Name of the method being captured in the context
+     */
+    beforeMethod(methodName) {
+        if (this.isFinished) {
+            this.result = new MethodExecutionResult();
+        }
+        this.methods.push(methodName);
+    }
+    /**
+     * Removes the latest method from the execution context stack,
+     * keeping track of the amount of 'unfinished' methods. Allowing
+     * for the context to distinguish between top-level and nested method calls.
+     */
+    afterMethod() {
+        this.methods.pop();
+    }
+    get isTopLevel() {
+        return this.isFinished;
+    }
+    get isFinished() {
+        return this.methods.length === 0;
+    }
+    /**
+     * @returns - Current execution context state
+     */
+    current() {
+        return {
+            isFinished: this.isFinished,
+            result: this.result,
+        };
+    }
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear() {
+        this.result = new MethodExecutionResult();
+    }
+};
+MethodExecutionContext = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [MethodExecutionResult])
+], MethodExecutionContext);
+export { MethodExecutionContext };

package/dist/method/MethodParameterDecoder.d.ts

@@ -0,0 +1,20 @@
+import { Field } from "snarkyjs";
+import { RuntimeModule } from "../runtime/RuntimeModule";
+export interface Fieldable {
+    toFields: () => Field[];
+}
+export interface FromFieldClass {
+    new: (...args: any[]) => any;
+    fromFields: (fields: Field[]) => Fieldable;
+    prototype: {
+        _fields: any[];
+    };
+}
+export declare class MethodParameterDecoder {
+    private readonly types;
+    static fromMethod(target: RuntimeModule<unknown>, methodName: string): MethodParameterDecoder;
+    private constructor();
+    fromFields(fields: Field[]): Fieldable[];
+    get fieldSize(): number;
+}
+//# sourceMappingURL=MethodParameterDecoder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MethodParameterDecoder.d.ts","sourceRoot":"","sources":["../../src/method/MethodParameterDecoder.ts"],"names":[],"mappings":"AAAA,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;IAE3C,SAAS,EAAE;QACT,OAAO,EAAE,GAAG,EAAE,CAAC;KAChB,CAAC;CACH;AAOD,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;IAc/C,IAAW,SAAS,IAAI,MAAM,CAI7B;CACF"}

package/dist/method/MethodParameterDecoder.js

@@ -0,0 +1,30 @@
+const errors = {
+    fieldLengthNotMatching: (expected, actual) => new Error(`Expected ${expected} field elements, got ${actual}`),
+};
+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) => {
+            // eslint-disable-next-line no-underscore-dangle
+            const numberFieldsNeeded = type.prototype._fields.length;
+            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)
+            .reduce((a, b) => a + b);
+    }
+}

package/dist/method/RuntimeMethodExecutionContext.d.ts

@@ -0,0 +1,57 @@
+import { Bool } from "snarkyjs";
+import type { StateTransition, NetworkState } from "@proto-kit/protocol";
+import { ProvableMethodExecutionContext, ProvableMethodExecutionResult } from "@proto-kit/common";
+import { RuntimeTransaction } from "@proto-kit/protocol/src/model/transaction/RuntimeTransaction";
+export declare class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutionResult {
+    stateTransitions: StateTransition<any>[];
+    status: Bool;
+    statusMessage?: string;
+}
+export interface RuntimeMethodExecutionData {
+    transaction: RuntimeTransaction;
+    networkState: NetworkState;
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+export declare class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
+    methods: string[];
+    input: RuntimeMethodExecutionData | undefined;
+    private lastInput;
+    result: RuntimeProvableMethodExecutionResult;
+    private assertSetupCalled;
+    /**
+     * Adds an in-method generated state transition to the current context
+     * @param stateTransition - State transition to add to the context
+     */
+    addStateTransition<Value>(stateTransition: StateTransition<Value>): void;
+    /**
+     * @param message - Status message to acompany the current status
+     */
+    setStatusMessage(message?: string): void;
+    /**
+     * @param status - Execution status of the current method
+     */
+    setStatus(status: Bool): void;
+    /**
+     * @param input Input witness data required for a runtime execution
+     */
+    setup(input: RuntimeMethodExecutionData): void;
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear(): void;
+    afterMethod(): void;
+    /**
+     * Had to override current() otherwise it would not infer
+     * the type of result correctly (parent type would be reused)
+     */
+    current(): {
+        isFinished: boolean;
+        result: RuntimeProvableMethodExecutionResult;
+        input: RuntimeMethodExecutionData | undefined;
+    };
+}
+//# sourceMappingURL=RuntimeMethodExecutionContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../src/method/RuntimeMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,8DAA8D,CAAC;AASlG,qBAAa,oCAAqC,SAAQ,6BAA6B;IAE9E,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;IAE9C,MAAM,EAAE,IAAI,CAAc;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,kBAAkB,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;GAIG;AACH,qBACa,6BAA8B,SAAQ,8BAA8B;IACxE,OAAO,EAAE,MAAM,EAAE,CAAM;IAEvB,KAAK,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAGrD,OAAO,CAAC,SAAS,CAAyC;IAE1C,MAAM,uCAA8C;IAEpE,OAAO,CAAC,iBAAiB;IAQzB;;;OAGG;IACI,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;IAKxE;;OAEG;IACI,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM;IAKxC;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAK7B;;OAEG;IACI,KAAK,CAAC,KAAK,EAAE,0BAA0B;IAI9C;;OAEG;IACI,KAAK;IAIL,WAAW;IAMlB;;;OAGG;IACI,OAAO;;;;;CAOf"}

package/dist/method/RuntimeMethodExecutionContext.js

@@ -0,0 +1,92 @@
+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 { Bool } from "snarkyjs";
+import { singleton } from "tsyringe";
+import { ProvableMethodExecutionContext, ProvableMethodExecutionResult, } from "@proto-kit/common";
+const errors = {
+    setupNotCalled: () => new Error("Setup has not been called prior to executing a runtime method. Be sure to do that so that the Runtime is setup property for execution"),
+};
+export class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutionResult {
+    constructor() {
+        super(...arguments);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.stateTransitions = [];
+        this.status = Bool(true);
+    }
+}
+/**
+ * Execution context used to wrap runtime module methods,
+ * allowing them to post relevant information (such as execution status)
+ * into the context without any unnecessary 'prop drilling'.
+ */
+let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
+    constructor() {
+        super(...arguments);
+        this.methods = [];
+        this.result = new RuntimeProvableMethodExecutionResult();
+    }
+    assertSetupCalled() {
+        if (this.input === undefined) {
+            throw errors.setupNotCalled();
+        }
+    }
+    /**
+     * Adds an in-method generated state transition to the current context
+     * @param stateTransition - State transition to add to the context
+     */
+    addStateTransition(stateTransition) {
+        this.assertSetupCalled();
+        this.result.stateTransitions.push(stateTransition);
+    }
+    /**
+     * @param message - Status message to acompany the current status
+     */
+    setStatusMessage(message) {
+        var _a;
+        this.assertSetupCalled();
+        (_a = this.result).statusMessage ?? (_a.statusMessage = message);
+    }
+    /**
+     * @param status - Execution status of the current method
+     */
+    setStatus(status) {
+        this.assertSetupCalled();
+        this.result.status = status;
+    }
+    /**
+     * @param input Input witness data required for a runtime execution
+     */
+    setup(input) {
+        this.input = input;
+    }
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear() {
+        this.result = new RuntimeProvableMethodExecutionResult();
+    }
+    afterMethod() {
+        super.afterMethod();
+        this.lastInput = this.input;
+        this.input = undefined;
+    }
+    /**
+     * Had to override current() otherwise it would not infer
+     * the type of result correctly (parent type would be reused)
+     */
+    current() {
+        return {
+            isFinished: this.isFinished,
+            result: this.result,
+            input: this.lastInput,
+        };
+    }
+};
+RuntimeMethodExecutionContext = __decorate([
+    singleton()
+], RuntimeMethodExecutionContext);
+export { RuntimeMethodExecutionContext };

package/dist/method/assert.d.ts

@@ -0,0 +1,12 @@
+import { Bool } from "snarkyjs";
+/**
+ * Maintains an execution status of the current runtime module method,
+ * while prioritizing one-time failures. The assertion won't change the
+ * execution status if it has previously failed at least once within the
+ * same method execution context.
+ *
+ * @param condition - Result of the assertion made about the execution status
+ * @param message - Optional message describing the prior status
+ */
+export declare function assert(condition: Bool, message?: string): void;
+//# sourceMappingURL=assert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/method/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,UAAU,CAAC;AAK1C;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAQvD"}

package/dist/method/assert.js

@@ -0,0 +1,20 @@
+import { Bool, Provable } from "snarkyjs";
+import { container } from "tsyringe";
+import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext";
+/**
+ * Maintains an execution status of the current runtime module method,
+ * while prioritizing one-time failures. The assertion won't change the
+ * execution status if it has previously failed at least once within the
+ * same method execution context.
+ *
+ * @param condition - Result of the assertion made about the execution status
+ * @param message - Optional message describing the prior status
+ */
+export function assert(condition, message) {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+    const previousStatus = executionContext.current().result.status;
+    const status = Provable.if(previousStatus, Bool, condition, previousStatus);
+    // const status = previousStatus.and(condition);
+    executionContext.setStatus(status);
+    executionContext.setStatusMessage(message);
+}

package/dist/method/decorator.d.ts

@@ -0,0 +1,45 @@
+import { Field } from "snarkyjs";
+import { StateTransition, MethodPublicInput } from "@yab/protocol";
+import type { RuntimeModule } from "../runtime/RuntimeModule.js";
+/**
+ * Runs a method wrapped in a method execution context.
+ */
+export declare function runInContext(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: unknown[]) => unknown, args: unknown[]): {
+    isFinished: boolean;
+    result: import("./MethodExecutionContext.js").MethodExecutionResult<unknown>;
+};
+export declare function toStateTransitionsHash(stateTransitions: StateTransition<any>[]): Field;
+export type WrappedMethod = (publicInput: MethodPublicInput, ...args: unknown[]) => unknown;
+export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: unknown[]) => unknown): WrappedMethod;
+export declare function combineMethodName(runtimeModuleName: string, methodName: string): string;
+/**
+ * Precomputes the public inputs required to run
+ * an actual wrapped method, produced from the provided moduleMethod.
+ *
+ * Execute the wrapped method with the precomputed public inputs.
+ */
+export declare function runWithCommitments(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: unknown[]) => unknown, args: unknown[]): unknown;
+export declare const methodMetadataKey = "yab-method";
+/**
+ * Checks the metadata of the provided runtime module and its method,
+ * to see if it has been decorated with @method()
+ *
+ * @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 isMethod(target: RuntimeModule<unknown>, propertyKey: string): boolean;
+export type DecoratedMethod = (...args: unknown[]) => unknown;
+/**
+ * Decorates a runtime module method and toggles execution of
+ * either of its variants, depending on the state of the current
+ * method execution context. If the method is called at the 'top-level',
+ * it is executed 'with commitments'. If the method is called from another
+ * method, it's executed directly.
+ *
+ * Additionally the method is marked with metadata as a 'runtime module method'.
+ *
+ * @returns A decorated runtime module method
+ */
+export declare function method(): (target: RuntimeModule<unknown>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+//# sourceMappingURL=decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/method/decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,OAAO,EACL,eAAe,EAGf,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAqBjE;;GAEG;AAEH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EAC7C,IAAI,EAAE,OAAO,EAAE;;;EAuBhB;AAED,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,SAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAC1B,WAAW,EAAE,iBAAiB,EAC9B,GAAG,IAAI,EAAE,OAAO,EAAE,KACf,OAAO,CAAC;AAEb,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,iBAiC9C;AAED,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,MAAM,UAGnB;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EAC7C,IAAI,EAAE,OAAO,EAAE,WA4ChB;AAED,eAAO,MAAM,iBAAiB,eAAe,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,MAAM,WAE3E;AAGD,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,aAEV,cAAc,OAAO,CAAC,eACjB,MAAM,cACP,kBAAkB,UAyBjC"}

package/dist/method/decorator.js

@@ -0,0 +1,140 @@
+import { Field } from "snarkyjs";
+import { container } from "tsyringe";
+import { DefaultProvableHashList, ProvableStateTransition, } from "@yab/protocol";
+import { MethodExecutionContext } from "./MethodExecutionContext.js";
+const errors = {
+    inconsistentStateTransitions: (methodName) => `State transitions produced by '@method ${methodName}' are not consistent 
+    through multiple method executions, does your method contain 
+    any circuit-unfriendly conditional logic?`,
+    inconsistentExecutionStatus: (methodName) => `Execution status of '@method ${methodName}' differs across multiple method executions, 
+    does your status change by any circuit-unfriendly conditional logic?`,
+    proverMissing: (methodName) => new Error(`Unable to find a provable method for '@method ${methodName}', 
+      did you forget to run chain.compile()?`),
+};
+/**
+ * Runs a method wrapped in a method execution context.
+ */
+export function runInContext(methodName, moduleMethod, args) {
+    const executionContext = container.resolve(MethodExecutionContext);
+    // eslint-disable-next-line @typescript-eslint/init-declarations
+    let resultValue;
+    executionContext.beforeMethod(methodName);
+    try {
+        resultValue = Reflect.apply(moduleMethod, this, args);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (error) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        throw new Error(error);
+    }
+    finally {
+        executionContext.afterMethod();
+    }
+    executionContext.setValue(resultValue);
+    return executionContext.current();
+}
+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 wrappedMethod = (publicInput, ...args) => {
+        const { result: { stateTransitions, status, value }, } = Reflect.apply(runInContext, this, [methodName, moduleMethod, args]);
+        const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
+        publicInput.stateTransitionsHash.assertEquals(stateTransitionsHash, errors.inconsistentStateTransitions(methodName));
+        // eslint-disable-next-line no-warning-comments
+        // TODO: implement the transactionHash commitment
+        publicInput.transactionHash.assertEquals(Field(0));
+        publicInput.status.assertEquals(status, errors.inconsistentExecutionStatus(methodName));
+        return value;
+    };
+    Object.defineProperty(wrappedMethod, "name", {
+        value: `wrapped_${methodName}`,
+        writable: false,
+    });
+    return wrappedMethod;
+}
+export function combineMethodName(runtimeModuleName, methodName) {
+    return `${runtimeModuleName}.${methodName}`;
+}
+/**
+ * Precomputes the public inputs required to run
+ * an actual wrapped method, produced from the provided moduleMethod.
+ *
+ * Execute the wrapped method with the precomputed public inputs.
+ */
+export function runWithCommitments(methodName, moduleMethod, args) {
+    const executionContext = container.resolve(MethodExecutionContext);
+    const wrappedMethod = Reflect.apply(toWrappedMethod, this, [
+        methodName,
+        moduleMethod,
+    ]);
+    const { result: { stateTransitions, status }, } = Reflect.apply(runInContext, this, [methodName, moduleMethod, args]);
+    const stateTransitionsHash = toStateTransitionsHash(stateTransitions);
+    const methodPublicInput = {
+        stateTransitionsHash,
+        transactionHash: Field(0),
+        status,
+    };
+    executionContext.setPublicInput(methodPublicInput);
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (this.runtime?.areProofsEnabled) {
+        const runtimeModuleName = this.constructor.name;
+        const combinedMethodName = combineMethodName(runtimeModuleName, methodName);
+        const provableMethod = this.runtime.program?.[combinedMethodName];
+        if (!provableMethod) {
+            throw errors.proverMissing(methodName);
+        }
+        const prove = async () => await Reflect.apply(provableMethod, this, [methodPublicInput, ...args]);
+        const result = wrappedMethod(methodPublicInput, ...args);
+        executionContext.setProve(prove);
+        return result;
+    }
+    return wrappedMethod(methodPublicInput, ...args);
+}
+export const methodMetadataKey = "yab-method";
+/**
+ * Checks the metadata of the provided runtime module and its method,
+ * to see if it has been decorated with @method()
+ *
+ * @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 isMethod(target, propertyKey) {
+    return Boolean(Reflect.getMetadata(methodMetadataKey, target, propertyKey));
+}
+/**
+ * Decorates a runtime module method and toggles execution of
+ * either of its variants, depending on the state of the current
+ * method execution context. If the method is called at the 'top-level',
+ * it is executed 'with commitments'. If the method is called from another
+ * method, it's executed directly.
+ *
+ * Additionally the method is marked with metadata as a 'runtime module method'.
+ *
+ * @returns A decorated runtime module method
+ */
+export function method() {
+    return (target, propertyKey, descriptor) => {
+        const executionContext = container.resolve(MethodExecutionContext);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const originalFunction = descriptor.value;
+        Reflect.defineMetadata(methodMetadataKey, true, target, propertyKey);
+        descriptor.value = function value(...args) {
+            if (executionContext.isTopLevel) {
+                return Reflect.apply(runWithCommitments, this, [
+                    propertyKey,
+                    originalFunction,
+                    args,
+                ]);
+            }
+            return Reflect.apply(originalFunction, this, args);
+        };
+    };
+}

package/dist/method/runtimeMethod.d.ts

@@ -0,0 +1,18 @@
+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";
+/**
+ * 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