@proto-kit/protocol 0.1.1-develop.190 → 0.1.1-develop.211

package/dist/state/State.d.ts

@@ -0,0 +1,60 @@
+import { Field, type FlexibleProvablePure } from "snarkyjs";
+import { Path } from "../model/Path";
+import { Option } from "../model/Option";
+import { StateServiceProvider } from "./StateServiceProvider";
+export declare class WithPath {
+    path?: Field;
+    hasPathOrFail(): asserts this is {
+        path: Path;
+    };
+}
+export declare class WithStateServiceProvider {
+    stateServiceProvider?: StateServiceProvider;
+    hasStateServiceOrFail(): asserts this is {
+        stateServiceProvider: StateServiceProvider;
+    };
+}
+declare const State_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider, 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>;
+    constructor(valueType: FlexibleProvablePure<Value>);
+    private getState;
+    /**
+     * 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

@@ -0,0 +1 @@
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../src/state/State.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAAY,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAI5E,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D,qBAAa,QAAQ;IACZ,IAAI,CAAC,EAAE,KAAK,CAAC;IAEb,aAAa,IAAI,OAAO,CAAC,IAAI,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;CAOvD;AAED,qBAAa,wBAAwB;IAC5B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAE5C,qBAAqB,IAAI,OAAO,CAAC,IAAI,IAAI;QAC9C,oBAAoB,EAAE,oBAAoB,CAAC;KAC5C;CAOF;;AAED;;GAEG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,UAAyC;IAW/C,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAVhE;;;;;OAKG;WACW,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;gBAItC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAIhE,OAAO,CAAC,QAAQ;IAuChB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAUpB;;;;;OAKG;IACI,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC;IAc3B;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,KAAK;CAiBxB"}

package/dist/state/State.js

@@ -0,0 +1,116 @@
+import { Mixin } from "ts-mixer";
+import { Bool, Provable } from "snarkyjs";
+import { container } from "tsyringe";
+import { dummyValue } from "@proto-kit/common";
+import { Option } from "../model/Option";
+import { StateTransition } from "../model/StateTransition";
+import { RuntimeMethodExecutionContext } from "./context/RuntimeMethodExecutionContext";
+export class WithPath {
+    hasPathOrFail() {
+        if (!this.path) {
+            throw new Error("Could not find 'path', did you forget to add '@state' to your state property?");
+        }
+    }
+}
+export class WithStateServiceProvider {
+    hasStateServiceOrFail() {
+        if (!this.stateServiceProvider) {
+            throw new Error("Could not find 'stateServiceProvider', did you forget to add '@state' to your state property?");
+        }
+    }
+}
+/**
+ * Utilities for runtime module state, such as get/set
+ */
+export class State extends Mixin(WithPath, WithStateServiceProvider) {
+    /**
+     * 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(valueType) {
+        return new State(valueType);
+    }
+    constructor(valueType) {
+        super();
+        this.valueType = valueType;
+    }
+    getState() {
+        this.hasStateServiceOrFail();
+        this.hasPathOrFail();
+        const { path, stateServiceProvider, valueType } = this;
+        const { stateTransitions } = container
+            .resolve(RuntimeMethodExecutionContext)
+            .current().result;
+        // First try to find a match inside already created stateTransitions
+        const previousMutatingTransitions = stateTransitions.filter((transition) => transition.path.equals(path).and(transition.to.isSome).toBoolean());
+        const pmtLength = previousMutatingTransitions.length;
+        let value = pmtLength > 0
+            ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                previousMutatingTransitions[pmtLength - 1].to.value
+            : undefined;
+        if (value !== undefined) {
+            return { value, isSome: Bool(true) };
+        }
+        // If the value is still undefined, look it up in the stateService
+        const fields = stateServiceProvider.stateService.get(path);
+        if (fields) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            value = valueType.fromFields(fields);
+        }
+        if (value !== undefined) {
+            return { value, isSome: Bool(true) };
+        }
+        return { value: dummyValue(valueType), isSome: Bool(false) };
+    }
+    /**
+     * Provides an in-circuit witness for the current state representation,
+     * and constructs an Option out of it.
+     *
+     * @returns Optional value of the current state
+     */
+    witnessState() {
+        // get the value from storage, or return a dummy value instead
+        const value = Provable.witness(this.valueType, () => this.getState().value);
+        // check if the value exists in the storage or not
+        const isSome = Provable.witness(Bool, () => this.getState().isSome);
+        return Option.from(isSome, value, this.valueType);
+    }
+    /**
+     * 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() {
+        const option = this.witnessState();
+        this.hasPathOrFail();
+        const stateTransition = StateTransition.from(this.path, option);
+        container
+            .resolve(RuntimeMethodExecutionContext)
+            .addStateTransition(stateTransition);
+        return option;
+    }
+    /**
+     * 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) {
+        // link the transition to the current state
+        const fromOption = this.witnessState();
+        const toOption = Option.from(Bool(true), value, this.valueType);
+        this.hasPathOrFail();
+        const stateTransition = StateTransition.fromTo(this.path, fromOption, toOption);
+        container
+            .resolve(RuntimeMethodExecutionContext)
+            .addStateTransition(stateTransition);
+    }
+}

package/dist/state/StateMap.d.ts

@@ -0,0 +1,37 @@
+import type { Field, FlexibleProvablePure } from "snarkyjs";
+import { Option } from "../model/Option";
+import { WithStateServiceProvider, WithPath } from "./State";
+declare const StateMap_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider, false>;
+/**
+ * Map-like wrapper for state
+ */
+export declare class StateMap<KeyType, ValueType> extends StateMap_base {
+    keyType: FlexibleProvablePure<KeyType>;
+    valueType: FlexibleProvablePure<ValueType>;
+    /**
+     * Create a new state map with the given key and value types
+     *
+     * @param keyType - Type to be used as a key
+     * @param valueType - Type to be stored as a value
+     * @returns State map with provided key and value types.
+     */
+    static from<KeyType, ValueType>(keyType: FlexibleProvablePure<KeyType>, valueType: FlexibleProvablePure<ValueType>): StateMap<KeyType, ValueType>;
+    constructor(keyType: FlexibleProvablePure<KeyType>, valueType: FlexibleProvablePure<ValueType>);
+    getPath(key: KeyType): Field;
+    /**
+     * Obtains a value for the provided key in the current state map.
+     *
+     * @param key - Key to obtain the state for
+     * @returns Value for the provided key.
+     */
+    get(key: KeyType): Option<ValueType>;
+    /**
+     * Sets a value for the given key in the current state map.
+     *
+     * @param key - Key to store the value under
+     * @param value - Value to be stored under the given key
+     */
+    set(key: KeyType, value: ValueType): void;
+}
+export {};
+//# sourceMappingURL=StateMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateMap.d.ts","sourceRoot":"","sources":["../../src/state/StateMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAI5D,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAS,wBAAwB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;;AAEpE;;GAEG;AAEH,qBAAa,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAE,SAAQ,aAGjD;IAgBU,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAhBnD;;;;;;OAMG;WACW,IAAI,CAAC,OAAO,EAAE,SAAS,EACnC,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC,GACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;gBAKtB,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAK5C,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK;IAKnC;;;;;OAKG;IACI,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC;IAU3C;;;;;OAKG;IACI,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;CASjD"}

package/dist/state/StateMap.js

@@ -0,0 +1,56 @@
+import { Mixin } from "ts-mixer";
+import { Path } from "../model/Path";
+import { State, WithStateServiceProvider, WithPath } from "./State";
+/**
+ * Map-like wrapper for state
+ */
+// eslint-disable-next-line new-cap
+export class StateMap extends Mixin(WithPath, WithStateServiceProvider) {
+    /**
+     * Create a new state map with the given key and value types
+     *
+     * @param keyType - Type to be used as a key
+     * @param valueType - Type to be stored as a value
+     * @returns State map with provided key and value types.
+     */
+    static from(keyType, valueType) {
+        return new StateMap(keyType, valueType);
+    }
+    constructor(keyType, valueType) {
+        super();
+        this.keyType = keyType;
+        this.valueType = valueType;
+    }
+    getPath(key) {
+        this.hasPathOrFail();
+        return Path.fromKey(this.path, this.keyType, key);
+    }
+    /**
+     * Obtains a value for the provided key in the current state map.
+     *
+     * @param key - Key to obtain the state for
+     * @returns Value for the provided key.
+     */
+    get(key) {
+        const state = State.from(this.valueType);
+        this.hasPathOrFail();
+        this.hasStateServiceOrFail();
+        state.path = this.getPath(key);
+        state.stateServiceProvider = this.stateServiceProvider;
+        return state.get();
+    }
+    /**
+     * Sets a value for the given key in the current state map.
+     *
+     * @param key - Key to store the value under
+     * @param value - Value to be stored under the given key
+     */
+    set(key, value) {
+        const state = State.from(this.valueType);
+        this.hasPathOrFail();
+        this.hasStateServiceOrFail();
+        state.path = Path.fromKey(this.path, this.keyType, key);
+        state.stateServiceProvider = this.stateServiceProvider;
+        state.set(value);
+    }
+}

package/dist/state/StateService.d.ts

@@ -0,0 +1,6 @@
+import { Field } from "snarkyjs";
+export interface StateService {
+    get: (key: Field) => Field[] | undefined;
+    set: (key: Field, value: Field[] | undefined) => void;
+}
+//# sourceMappingURL=StateService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateService.d.ts","sourceRoot":"","sources":["../../src/state/StateService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,KAAK,EAAE,GAAG,SAAS,CAAC;IACzC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,SAAS,KAAK,IAAI,CAAC;CACvD"}

package/dist/state/StateService.js

@@ -0,0 +1 @@
+export {};

package/dist/state/StateServiceProvider.d.ts

@@ -0,0 +1,10 @@
+import { StateService } from "./StateService";
+export declare class StateServiceProvider {
+    private currentStateService?;
+    private readonly defaultStateService?;
+    constructor(currentStateService?: StateService | undefined);
+    get stateService(): StateService;
+    setCurrentStateService(service: StateService): void;
+    resetToDefault(): void;
+}
+//# sourceMappingURL=StateServiceProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateServiceProvider.d.ts","sourceRoot":"","sources":["../../src/state/StateServiceProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAW9C,qBACa,oBAAoB;IAKL,OAAO,CAAC,mBAAmB,CAAC;IAJtD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CACV;gBAGO,mBAAmB,CAAC,0BAAc;IAGpE,IAAW,YAAY,IAAI,YAAY,CAKtC;IAEM,sBAAsB,CAAC,OAAO,EAAE,YAAY;IAI5C,cAAc;CAGtB"}

package/dist/state/StateServiceProvider.js

@@ -0,0 +1,42 @@
+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 { inject, injectable } from "tsyringe";
+const errors = {
+    stateServiceNotSet: () => new Error(`StateService has not been set yet. Be sure to either call your runtime or 
+      protocol function by creating them with an AppChain or by setting the 
+      stateService manually.`),
+};
+let StateServiceProvider = class StateServiceProvider {
+    constructor(currentStateService) {
+        this.currentStateService = currentStateService;
+        this.defaultStateService = this.currentStateService;
+    }
+    get stateService() {
+        if (this.currentStateService === undefined) {
+            throw errors.stateServiceNotSet();
+        }
+        return this.currentStateService;
+    }
+    setCurrentStateService(service) {
+        this.currentStateService = service;
+    }
+    resetToDefault() {
+        this.currentStateService = this.defaultStateService;
+    }
+};
+StateServiceProvider = __decorate([
+    injectable(),
+    __param(0, inject("StateService")),
+    __metadata("design:paramtypes", [Object])
+], StateServiceProvider);
+export { StateServiceProvider };

package/dist/state/assert/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/state/assert/assert.d.ts.map

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

package/dist/state/assert/assert.js

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

package/dist/state/context/ProtocolMethodExecutionContext.d.ts

@@ -0,0 +1,22 @@
+import { TransitionMethodExecutionContext, TransitionMethodExecutionResult } from "./TransitionMethodExecutionContext";
+import { StateTransition } from "../../model/StateTransition";
+export declare class ProtocolMethodExecutionContext implements TransitionMethodExecutionContext {
+    result: TransitionMethodExecutionResult;
+    /**
+     * 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;
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear(): void;
+    /**
+     * Had to override current() otherwise it would not infer
+     * the type of result correctly (parent type would be reused)
+     */
+    current(): {
+        result: TransitionMethodExecutionResult;
+    };
+}
+//# sourceMappingURL=ProtocolMethodExecutionContext.d.ts.map

package/dist/state/context/ProtocolMethodExecutionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/state/context/ProtocolMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gCAAgC,EAChC,+BAA+B,EAChC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,qBAAa,8BAA+B,YAAW,gCAAgC;IAC9E,MAAM,kCAAyC;IAEtD;;;OAGG;IACI,kBAAkB,CAAC,KAAK,EAC7B,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;IAKzC;;OAEG;IACI,KAAK;IAIZ;;;OAGG;IACI,OAAO;;;CAKf"}

package/dist/state/context/ProtocolMethodExecutionContext.js

@@ -0,0 +1,28 @@
+import { TransitionMethodExecutionResult } from "./TransitionMethodExecutionContext";
+export class ProtocolMethodExecutionContext {
+    constructor() {
+        this.result = new TransitionMethodExecutionResult();
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear() {
+        this.result = new TransitionMethodExecutionResult();
+    }
+    /**
+     * Had to override current() otherwise it would not infer
+     * the type of result correctly (parent type would be reused)
+     */
+    current() {
+        return {
+            result: this.result,
+        };
+    }
+}

package/dist/state/context/RuntimeMethodExecutionContext.d.ts

@@ -0,0 +1,60 @@
+import { Bool } from "snarkyjs";
+import { ProvableMethodExecutionContext, ProvableMethodExecutionResult } from "@proto-kit/common";
+import { StateTransition } from "../../model/StateTransition";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
+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 isSimulated;
+    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;
+    setSimulated(simulated: boolean): 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/state/context/RuntimeMethodExecutionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/state/context/RuntimeMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAClG,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAShE,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,WAAW,CAAkB;IAErC,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;IAQxC;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAQ7B;;OAEG;IACI,KAAK,CAAC,KAAK,EAAE,0BAA0B;IAIvC,YAAY,CAAC,SAAS,EAAE,OAAO;IAItC;;OAEG;IACI,KAAK;IAIL,WAAW;IASlB;;;OAGG;IACI,OAAO;;;;;CAOf"}

package/dist/state/context/RuntimeMethodExecutionContext.js

@@ -0,0 +1,105 @@
+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();
+        this.isSimulated = false;
+    }
+    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();
+        if (this.isSimulated) {
+            return;
+        }
+        (_a = this.result).statusMessage ?? (_a.statusMessage = message);
+    }
+    /**
+     * @param status - Execution status of the current method
+     */
+    setStatus(status) {
+        this.assertSetupCalled();
+        if (this.isSimulated) {
+            return;
+        }
+        this.result.status = status;
+    }
+    /**
+     * @param input Input witness data required for a runtime execution
+     */
+    setup(input) {
+        this.input = input;
+    }
+    setSimulated(simulated) {
+        this.isSimulated = simulated;
+    }
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear() {
+        this.result = new RuntimeProvableMethodExecutionResult();
+    }
+    afterMethod() {
+        super.afterMethod();
+        if (this.isFinished) {
+            this.lastInput = this.input;
+            this.input = undefined;
+            this.isSimulated = false;
+        }
+    }
+    /**
+     * 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/state/context/TransitionMethodExecutionContext.d.ts

@@ -0,0 +1,23 @@
+import { StateTransition } from "../../model/StateTransition";
+export declare class TransitionMethodExecutionResult {
+    stateTransitions: StateTransition<any>[];
+}
+export interface TransitionMethodExecutionContext {
+    /**
+     * 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;
+    /**
+     * Manually clears/resets the execution context
+     */
+    clear: () => void;
+    /**
+     * Had to override current() otherwise it would not infer
+     * the type of result correctly (parent type would be reused)
+     */
+    current: () => {
+        result: TransitionMethodExecutionResult;
+    };
+}
+//# sourceMappingURL=TransitionMethodExecutionContext.d.ts.map

package/dist/state/context/TransitionMethodExecutionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransitionMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/state/context/TransitionMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,qBAAa,+BAA+B;IAEnC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;CACtD;AAED,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,kBAAkB,EAAE,CAAC,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAE7E;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAElB;;;OAGG;IACH,OAAO,EAAE,MAAM;QACb,MAAM,EAAE,+BAA+B,CAAC;KACzC,CAAC;CACH"}

package/dist/state/context/TransitionMethodExecutionContext.js

@@ -0,0 +1,6 @@
+export class TransitionMethodExecutionResult {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.stateTransitions = [];
+    }
+}