@proto-kit/module 0.1.1-develop.164 → 0.1.1-develop.185

package/dist/method/MethodExecutionContext.js

@@ -1,112 +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 { 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/decorator.d.ts

@@ -1,45 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,140 +0,0 @@
-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);
-        };
-    };
-}