@proto-kit/module 0.1.1-develop.165 → 0.1.1-develop.1665

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/MethodParameterDecoder.d.ts

@@ -1,22 +0,0 @@
-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;
-    name: string;
-    prototype: {
-        _fields?: any[];
-    };
-    sizeInFields?: () => number;
-}
-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

@@ -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;IAiB/C,IAAW,SAAS,IAAI,MAAM,CAM7B;CACF"}

package/dist/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);
-    }
-}

package/dist/method/RuntimeMethodExecutionContext.d.ts

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

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

@@ -1,92 +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;
-};
-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

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

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

package/dist/method/assert.js

@@ -1,23 +0,0 @@
-import { Bool, Provable } from "snarkyjs";
-import { container } from "tsyringe";
-import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext";
-import { log } from "@proto-kit/common";
-/**
- * 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);
-    if (!condition.toBoolean()) {
-        log.debug("Assertion failed: ", message);
-        executionContext.setStatusMessage(message);
-    }
-    executionContext.setStatus(status);
-}

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);
-        };
-    };
-}

package/dist/state/State.d.ts

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

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

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