@proto-kit/module 0.1.1-develop.191 → 0.1.1-develop.239

package/dist/protocol/src/model/StateTransition.js

@@ -0,0 +1,65 @@
+import { Field, Struct } from "snarkyjs";
+import { Option, ProvableOption } from "./Option.js";
+/**
+ * Provable representation of a State Transition, used to
+ * normalize state transitions of various value types for
+ * the state transition circuit.
+ */
+export class ProvableStateTransition extends Struct({
+    path: Field,
+    // must be applied even if `None`
+    from: ProvableOption,
+    // must be ignored if `None`
+    to: ProvableOption,
+}) {
+    static dummy() {
+        return new ProvableStateTransition({
+            path: Field(0),
+            from: Option.none().toProvable(),
+            to: Option.none().toProvable(),
+        });
+    }
+}
+/**
+ * Generic state transition that constraints the current method circuit
+ * to external state, by providing a state anchor.
+ */
+export class StateTransition {
+    static from(path, fromValue) {
+        return new StateTransition(path, fromValue, Option.none());
+    }
+    static fromTo(path, fromValue, toValue) {
+        return new StateTransition(path, fromValue, toValue);
+    }
+    constructor(path, fromValue, toValue) {
+        this.path = path;
+        this.fromValue = fromValue;
+        this.toValue = toValue;
+    }
+    get from() {
+        const from = this.fromValue.clone();
+        from.forceSome();
+        return from;
+    }
+    get to() {
+        return this.toValue.clone();
+    }
+    /**
+     * Converts a StateTransition to a ProvableStateTransition,
+     * while enforcing the 'from' property to be 'Some' in all cases.
+     */
+    toProvable() {
+        return new ProvableStateTransition({
+            path: this.path,
+            from: this.from.toProvable(),
+            to: this.to.toProvable(),
+        });
+    }
+    toJSON() {
+        return {
+            path: this.path.toString(),
+            from: this.from.toJSON(),
+            to: this.to.toJSON(),
+        };
+    }
+}

package/dist/protocol/src/model/network/NetworkState.d.ts

@@ -0,0 +1,64 @@
+import { Field, UInt64 } from "snarkyjs";
+declare const CurrentBlock_base: (new (value: {
+    height: UInt64;
+}) => {
+    height: UInt64;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    height: UInt64;
+}> & {
+    toInput: (x: {
+        height: UInt64;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        height: UInt64;
+    }) => {
+        height: string;
+    };
+    fromJSON: (x: {
+        height: string;
+    }) => {
+        height: UInt64;
+    };
+};
+export declare class CurrentBlock extends CurrentBlock_base {
+}
+declare const NetworkState_base: (new (value: {
+    block: CurrentBlock;
+}) => {
+    block: CurrentBlock;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    block: CurrentBlock;
+}> & {
+    toInput: (x: {
+        block: CurrentBlock;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        block: CurrentBlock;
+    }) => {
+        block: {
+            height: string;
+        };
+    };
+    fromJSON: (x: {
+        block: {
+            height: string;
+        };
+    }) => {
+        block: CurrentBlock;
+    };
+};
+export declare class NetworkState extends NetworkState_base {
+    hash(): Field;
+}
+export {};
+//# sourceMappingURL=NetworkState.d.ts.map

package/dist/protocol/src/model/network/NetworkState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkState.d.ts","sourceRoot":"","sources":["../../../../../../protocol/src/model/network/NetworkState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3D,qBAAa,YAAa,SAAQ,iBAEhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAEhC;IACO,IAAI,IAAI,KAAK;CAGrB"}

package/dist/protocol/src/model/network/NetworkState.js

@@ -0,0 +1,12 @@
+import { Poseidon, Struct, UInt64 } from "snarkyjs";
+export class CurrentBlock extends Struct({
+    height: UInt64,
+}) {
+}
+export class NetworkState extends Struct({
+    block: CurrentBlock,
+}) {
+    hash() {
+        return Poseidon.hash(CurrentBlock.toFields(this.block));
+    }
+}

package/dist/protocol/src/model/transaction/ProtocolTransaction.d.ts

@@ -0,0 +1,70 @@
+import { Bool, Field, PublicKey, Signature, UInt64 } from "snarkyjs";
+declare const ProtocolTransaction_base: (new (value: {
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    signature: Signature;
+}) => {
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    signature: Signature;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    signature: Signature;
+}> & {
+    toInput: (x: {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        signature: Signature;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        signature: Signature;
+    }) => {
+        methodId: string;
+        nonce: string;
+        sender: string;
+        argsHash: string;
+        signature: any;
+    };
+    fromJSON: (x: {
+        methodId: string;
+        nonce: string;
+        sender: string;
+        argsHash: string;
+        signature: any;
+    }) => {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+        signature: Signature;
+    };
+};
+export declare class ProtocolTransaction extends ProtocolTransaction_base {
+    static getSignatureData(args: {
+        methodId: Field;
+        nonce: UInt64;
+        argsHash: Field;
+    }): Field[];
+    getSignatureData(): Field[];
+    validateSignature(): Bool;
+}
+export {};
+//# sourceMappingURL=ProtocolTransaction.d.ts.map

package/dist/protocol/src/model/transaction/ProtocolTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolTransaction.d.ts","sourceRoot":"","sources":["../../../../../../protocol/src/model/transaction/ProtocolTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE7E,qBAAa,mBAAoB,SAAQ,wBAMvC;WACc,gBAAgB,CAAC,IAAI,EAAE;QACnC,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,KAAK,CAAC;KACjB,GAAG,KAAK,EAAE;IAIJ,gBAAgB,IAAI,KAAK,EAAE;IAI3B,iBAAiB,IAAI,IAAI;CAGjC"}

package/dist/protocol/src/model/transaction/ProtocolTransaction.js

@@ -0,0 +1,18 @@
+import { Field, PublicKey, Signature, Struct, UInt64 } from "snarkyjs";
+export class ProtocolTransaction extends Struct({
+    methodId: Field,
+    nonce: UInt64,
+    sender: PublicKey,
+    argsHash: Field,
+    signature: Signature,
+}) {
+    static getSignatureData(args) {
+        return [args.methodId, ...args.nonce.toFields(), args.argsHash];
+    }
+    getSignatureData() {
+        return ProtocolTransaction.getSignatureData(this);
+    }
+    validateSignature() {
+        return this.signature.verify(this.sender, this.getSignatureData());
+    }
+}

package/dist/protocol/src/model/transaction/RuntimeTransaction.d.ts

@@ -0,0 +1,63 @@
+import { Field, PublicKey, UInt64 } from "snarkyjs";
+import { ProtocolTransaction } from "./ProtocolTransaction";
+declare const RuntimeTransaction_base: (new (value: {
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+}) => {
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    methodId: import("snarkyjs/dist/node/lib/field").Field;
+    nonce: UInt64;
+    sender: PublicKey;
+    argsHash: import("snarkyjs/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        methodId: string;
+        nonce: string;
+        sender: string;
+        argsHash: string;
+    };
+    fromJSON: (x: {
+        methodId: string;
+        nonce: string;
+        sender: string;
+        argsHash: string;
+    }) => {
+        methodId: import("snarkyjs/dist/node/lib/field").Field;
+        nonce: UInt64;
+        sender: PublicKey;
+        argsHash: import("snarkyjs/dist/node/lib/field").Field;
+    };
+};
+/**
+ * This struct is used to expose transaction information to the runtime method
+ * execution. This class has not all data included in transactions on purpose.
+ * For example, we don't want to expose the signature or args as fields.
+ */
+export declare class RuntimeTransaction extends RuntimeTransaction_base {
+    static fromProtocolTransaction({ methodId, nonce, sender, argsHash, }: ProtocolTransaction): RuntimeTransaction;
+    hash(): Field;
+}
+export {};
+//# sourceMappingURL=RuntimeTransaction.d.ts.map

package/dist/protocol/src/model/transaction/RuntimeTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeTransaction.d.ts","sourceRoot":"","sources":["../../../../../../protocol/src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,SAAS,EAAU,MAAM,EAAE,MAAM,UAAU,CAAC;AAEtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,uBAKtC;WACc,uBAAuB,CAAC,EACpC,QAAQ,EACR,KAAK,EACL,MAAM,EACN,QAAQ,GACT,EAAE,mBAAmB,GAAG,kBAAkB;IASpC,IAAI,IAAI,KAAK;CAQrB"}

package/dist/protocol/src/model/transaction/RuntimeTransaction.js

@@ -0,0 +1,29 @@
+import { Field, Poseidon, PublicKey, Struct, UInt64 } from "snarkyjs";
+/**
+ * This struct is used to expose transaction information to the runtime method
+ * execution. This class has not all data included in transactions on purpose.
+ * For example, we don't want to expose the signature or args as fields.
+ */
+export class RuntimeTransaction extends Struct({
+    methodId: Field,
+    nonce: UInt64,
+    sender: PublicKey,
+    argsHash: Field,
+}) {
+    static fromProtocolTransaction({ methodId, nonce, sender, argsHash, }) {
+        return new RuntimeTransaction({
+            methodId,
+            nonce,
+            sender,
+            argsHash,
+        });
+    }
+    hash() {
+        return Poseidon.hash([
+            this.methodId,
+            ...this.sender.toFields(),
+            ...this.nonce.toFields(),
+            this.argsHash,
+        ]);
+    }
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../protocol/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/protocol/src/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/protocol/src/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/protocol/src/state/context/RuntimeMethodExecutionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../../../../protocol/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/protocol/src/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/runtime/Runtime.d.ts

@@ -1,10 +1,8 @@
 import { Experimental } from "snarkyjs";
 import { DependencyContainer } from "tsyringe";
 import { StringKeyOf, ModuleContainer, ModulesConfig, ModulesRecord, TypedClass, ZkProgrammable, PlainZkProgram, WithZkProgrammable, AreProofsEnabled } from "@proto-kit/common";
-import { MethodPublicOutput } from "@proto-kit/protocol";
-import { StateService } from "../state/InMemoryStateService.js";
-import { StateServiceProvider } from "../state/StateServiceProvider";
-import { RuntimeModule } from "./RuntimeModule.js";
+import { MethodPublicOutput, StateServiceProvider, StateService } from "@proto-kit/protocol";
+import { RuntimeModule } from "./RuntimeModule";
 /**
  * Record of modules accepted by the Runtime module container.
  *
@@ -16,7 +14,10 @@ export type RuntimeModulesRecord = ModulesRecord<TypedClass<RuntimeModule<unknow
  * Definition / required arguments for the Runtime class
  */
 export interface RuntimeDefinition<Modules extends RuntimeModulesRecord> {
-    state: StateService;
+    /**
+     * @deprecated
+     */
+    state?: StateService;
     modules: Modules;
     config?: ModulesConfig<Modules>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/Runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAc,MAAM,UAAU,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAQzD,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAGrE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnD;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAC9C,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CACnC,CAAC;AAOF;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,oBAAoB;IACrE,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,qBAAa,qBAAqB,CAChC,OAAO,SAAS,oBAAoB,CACpC,SAAQ,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;IAE3B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;gBAAzB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;IAInD,IAAW,QAAQ,iCAElB;IAEM,gBAAgB,IAAI,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;CAgHzE;AAED;;;GAGG;AACH,qBACa,OAAO,CAAC,OAAO,SAAS,oBAAoB,CACvD,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,CAAC;WAE9C,IAAI,CAAC,OAAO,SAAS,oBAAoB,EACrD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAMjC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;IAEpD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAEvC,cAAc,EAAE,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;IAIrE,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAE3C;IAEF;;;;OAIG;gBACgB,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAUlD,KAAK;IAOZ,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAED,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAEtD;IAED;;OAEG;IACH,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED;;;OAGG;IACI,aAAa,CAClB,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS;IAwBhD;;;;;;OAMG;IACI,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAQ9D;;OAEG;IACH,IAAW,kBAAkB,aAE5B;CACF"}
+{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/Runtime.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAc,MAAM,UAAU,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,eAAe,EACf,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACb,MAAM,qBAAqB,CAAC;AAU7B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAC9C,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CACnC,CAAC;AAOF;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,oBAAoB;IACrE;;OAEG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,qBAAa,qBAAqB,CAChC,OAAO,SAAS,oBAAoB,CACpC,SAAQ,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;IAE3B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;gBAAzB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;IAInD,IAAW,QAAQ,iCAElB;IAEM,gBAAgB,IAAI,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC;CAgHzE;AAED;;;GAGG;AACH,qBACa,OAAO,CAAC,OAAO,SAAS,oBAAoB,CACvD,SAAQ,eAAe,CAAC,OAAO,CAC/B,YAAW,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,CAAC;WAE9C,IAAI,CAAC,OAAO,SAAS,oBAAoB,EACrD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAMjC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;IAEpD,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAEvC,cAAc,EAAE,cAAc,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;IAErE,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAG3C;IAEF;;;;OAIG;gBACgB,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC;IAQlD,KAAK;IAOZ,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAED,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED,IAAW,oBAAoB,IAAI,oBAAoB,CAEtD;IAED;;OAEG;IACH,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED;;;OAGG;IACI,aAAa,CAClB,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS;IAwBhD;;;;;;OAMG;IACI,cAAc,CACnB,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;IAQ9D;;OAEG;IACH,IAAW,kBAAkB,aAE5B;CACF"}

package/dist/runtime/Runtime.js

@@ -13,9 +13,8 @@ var Runtime_1;
 import { Experimental } from "snarkyjs";
 import { injectable } from "tsyringe";
 import { ModuleContainer, ZkProgrammable, } from "@proto-kit/common";
-import { MethodPublicOutput } from "@proto-kit/protocol";
-import { combineMethodName, isRuntimeMethod, toWrappedMethod, } from "../method/runtimeMethod.js";
-import { StateServiceProvider } from "../state/StateServiceProvider";
+import { MethodPublicOutput, StateServiceProvider, } from "@proto-kit/protocol";
+import { combineMethodName, isRuntimeMethod, toWrappedMethod, } from "../method/runtimeMethod";
 import { MethodIdFactory } from "../factories/MethodIdFactory";
 const errors = {
     methodNotFound: (methodKey) => new Error(`Unable to find method with id ${methodKey}`),
@@ -107,12 +106,11 @@ let Runtime = Runtime_1 = class Runtime extends ModuleContainer {
      */
     constructor(definition) {
         super(definition);
-        // eslint-disable-next-line no-warning-comments
-        // TODO DI
-        this.stateServiceProviderInstance = new StateServiceProvider(this.definition.state);
+        this.stateServiceProviderInstance = new StateServiceProvider(
+        // eslint-disable-next-line etc/no-deprecated
+        this.definition.state);
         this.definition = definition;
         this.zkProgrammable = new RuntimeZkProgrammable(this);
-        // this.registerDependencyFactories([MethodIdFactory]);
     }
     // eslint-disable-next-line no-warning-comments
     // TODO Remove after changing DFs to type-based approach

package/dist/runtime/RuntimeModule.d.ts

@@ -1,6 +1,5 @@
 import { ConfigurableModule, Presets } from "@proto-kit/common";
-import { NetworkState, RuntimeTransaction } from "@proto-kit/protocol";
-import { StateService } from "../state/InMemoryStateService";
+import { NetworkState, RuntimeTransaction, StateService } from "@proto-kit/protocol";
 import type { Runtime, RuntimeDefinition, RuntimeModulesRecord } from "./Runtime";
 /**
  * This type exists to carry over certain runtime properties
@@ -26,7 +25,6 @@ export declare class RuntimeModule<Config> extends ConfigurableModule<Config> {
      */
     isRuntimeModule: boolean;
     name?: string;
-    test?: number;
     runtime?: Runtime<RuntimeModulesRecord>;
     constructor();
     private getInputs;

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

@@ -1 +1 @@
-{"version":3,"file":"RuntimeModule.d.ts","sourceRoot":"","sources":["../../src/runtime/RuntimeModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAMvE,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAG7D,OAAO,KAAK,EACV,OAAO,EACP,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,WAAW,CAAC;AAMnB;;;GAGG;AACH,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,gBAAgB,CAAC;IAC7D,UAAU,EAAE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC,CAAC;IAEnE,IAAI,YAAY,IAAI,YAAY,CAAC;CAClC;AAED;;GAEG;AACH,qBACa,aAAa,CAAC,MAAM,CAAE,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IACnE,OAAc,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAM;IAE7C;;OAEG;IACH,SAAgB,kBAAkB,EAAE,MAAM,EAAE,CAAM;IAElD;;;;OAIG;IACI,eAAe,UAAQ;IAEvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;;IAY/C,OAAO,CAAC,SAAS;IAWjB,IAAW,WAAW,IAAI,kBAAkB,CAE3C;IAED,IAAW,OAAO,IAAI,YAAY,CAEjC;CACF"}
+{"version":3,"file":"RuntimeModule.d.ts","sourceRoot":"","sources":["../../src/runtime/RuntimeModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,YAAY,EAGb,MAAM,qBAAqB,CAAC;AAI7B,OAAO,KAAK,EACV,OAAO,EACP,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,WAAW,CAAC;AAMnB;;;GAGG;AACH,MAAM,WAAW,cACf,SAAQ,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,gBAAgB,CAAC;IAC7D,UAAU,EAAE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC,CAAC;IAEnE,IAAI,YAAY,IAAI,YAAY,CAAC;CAClC;AAED;;GAEG;AACH,qBACa,aAAa,CAAC,MAAM,CAAE,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IACnE,OAAc,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAM;IAE7C;;OAEG;IACH,SAAgB,kBAAkB,EAAE,MAAM,EAAE,CAAM;IAElD;;;;OAIG;IACI,eAAe,UAAQ;IAEvB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;;IAY/C,OAAO,CAAC,SAAS;IAWjB,IAAW,WAAW,IAAI,kBAAkB,CAE3C;IAED,IAAW,OAAO,IAAI,YAAY,CAEjC;CACF"}

package/dist/runtime/RuntimeModule.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { ConfigurableModule } from "@proto-kit/common";
 import { container, injectable } from "tsyringe";
-import { RuntimeMethodExecutionContext, } from "../method/RuntimeMethodExecutionContext";
+import { RuntimeMethodExecutionContext, } from "@proto-kit/protocol";
 import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
 const errors = {
     inputDataNotSet: () => new Error("Input data for runtime execution not set"),

package/dist/state/InMemoryStateService.d.ts

@@ -1,8 +1,5 @@
 import { Field } from "snarkyjs";
-export interface StateService {
-    get: (key: Field) => Field[] | undefined;
-    set: (key: Field, value: Field[] | undefined) => void;
-}
+import { StateService } from "@proto-kit/protocol";
 /**
  * Naive implementation of a StateService for testing purposes
  */