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

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

@@ -1,11 +1,11 @@
 import type { Field, FlexibleProvablePure } from "snarkyjs";
-import { type Option } from "@proto-kit/protocol";
+import { type Option, ToFieldable } from "@proto-kit/protocol";
 import { WithRuntime, WithPath } from "./State.js";
 declare const StateMap_base: import("ts-mixer/dist/types/types.js").Class<any[], WithPath & WithRuntime, typeof WithPath & typeof WithRuntime, false>;
 /**
  * Map-like wrapper for state
  */
-export declare class StateMap<KeyType, ValueType> extends StateMap_base {
+export declare class StateMap<KeyType, ValueType extends ToFieldable> extends StateMap_base {
     keyType: FlexibleProvablePure<KeyType>;
     valueType: FlexibleProvablePure<ValueType>;
     /**
@@ -15,7 +15,7 @@ export declare class StateMap<KeyType, ValueType> extends StateMap_base {
      * @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>;
+    static from<KeyType, ValueType extends ToFieldable>(keyType: FlexibleProvablePure<KeyType>, valueType: FlexibleProvablePure<ValueType>): StateMap<KeyType, ValueType>;
     constructor(keyType: FlexibleProvablePure<KeyType>, valueType: FlexibleProvablePure<ValueType>);
     getPath(key: KeyType): Field;
     /**

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

@@ -1 +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;AAC5D,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGxD,OAAO,EAAS,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;;AAE1D;;GAEG;AAEH,qBAAa,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAE,SAAQ,aAA4B;IAgBnE,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;gBAMnC,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;CAS1C"}
+{"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;AAC5D,OAAO,EAAQ,KAAK,MAAM,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGrE,OAAO,EAAS,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;;AAE1D;;GAEG;AAEH,qBAAa,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,WAAW,CAAE,SAAQ,aAA4B;IAgBvF,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAhBnD;;;;;;OAMG;WACW,IAAI,CAAC,OAAO,EAAE,SAAS,SAAS,WAAW,EACvD,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;gBAMnC,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;CAS1C"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@proto-kit/module",
   "license": "MIT",
   "private": false,
-  "version": "0.1.1-develop.190+f5a17c3",
+  "version": "0.1.1-develop.211+662735c",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -21,8 +21,7 @@
     "@proto-kit/protocol": "*",
     "lodash": "^4.17.21",
     "loglevel": "^1.8.1",
-    "reflect-metadata": "^0.1.13",
-    "ts-mixer": "^6.0.3"
+    "reflect-metadata": "^0.1.13"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
@@ -32,5 +31,5 @@
     "snarkyjs": "0.12.0",
     "tsyringe": "^4.7.0"
   },
-  "gitHead": "f5a17c3c4cb13e568fa9802c9d15c27089cccf0d"
+  "gitHead": "662735cd072170aa01a9f6040e89293a3e3fc8a9"
 }

package/src/index.ts

@@ -1,13 +1,10 @@
-export * from "./method/RuntimeMethodExecutionContext";
-export * from "./method/assert";
+export * from "../../protocol/src/state/assert/assert";
 export * from "./method/runtimeMethod";
 export * from "./module/decorator";
 export * from "./runtime/RuntimeModule";
 export * from "./runtime/Runtime";
 export * from "./state/InMemoryStateService";
-export * from "./state/State";
-export * from "./state/StateMap";
-export * from "./state/StateServiceProvider";
+export * from "@proto-kit/protocol/src/state/StateServiceProvider";
 export * from "./state/decorator";
 export * from "./method/MethodParameterDecoder";
 export * from "./runtime/MethodIdResolver";

package/src/method/MethodParameterDecoder.ts

@@ -45,7 +45,9 @@ export class MethodParameterDecoder {
     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;
@@ -63,6 +65,6 @@ export class MethodParameterDecoder {
       .map(
         (type) => type.prototype._fields?.length ?? type.sizeInFields?.() ?? 0
       )
-      .reduce((a, b) => a + b);
+      .reduce((a, b) => a + b, 0);
   }
 }

package/src/method/runtimeMethod.ts

@@ -5,13 +5,12 @@ import {
   DefaultProvableHashList,
   ProvableStateTransition,
   MethodPublicOutput,
+  RuntimeMethodExecutionContext
 } from "@proto-kit/protocol";
 import { DecoratedMethod, toProver, ZkProgrammable } from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 
-import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext.js";
-
 const errors = {
   runtimeNotProvided: (name: string) =>
     new Error(`Runtime was not provided for module: ${name}`),