@proto-kit/module 0.1.1-develop.245 → 0.1.1-develop.254

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

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

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

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

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

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

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

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

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

@@ -1,105 +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();
-        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/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"}

package/dist/state/State.js

@@ -1,114 +0,0 @@
-/* eslint-disable new-cap */
-import { Mixin } from "ts-mixer";
-import { Bool, Field, Provable } from "snarkyjs";
-import { container } from "tsyringe";
-import { Option, StateTransition } from "@proto-kit/protocol";
-import { RuntimeMethodExecutionContext } from "../method/RuntimeMethodExecutionContext.js";
-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 WithRuntime {
-    hasRuntimeOrFail() {
-        if (!this.runtime) {
-            throw new Error("Could not find 'runtime', 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, WithRuntime) {
-    /**
-     * 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);
-    }
-    /**
-     * 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(valueType) {
-        const length = valueType.sizeInFields();
-        const fields = Array.from({ length }, () => Field(0));
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return valueType.fromFields(fields);
-    }
-    constructor(valueType) {
-        super();
-        this.valueType = valueType;
-    }
-    /**
-     * 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.hasRuntimeOrFail();
-            this.hasPathOrFail();
-            const fields = this.runtime.stateService.get(this.path);
-            if (fields) {
-                // eslint-disable-next-line max-len
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                return this.valueType.fromFields(fields);
-            }
-            return State.dummyValue(this.valueType);
-        });
-        // check if the value exists in the storage or not
-        const isSome = Provable.witness(Bool, () => {
-            this.hasRuntimeOrFail();
-            this.hasPathOrFail();
-            const fields = this.runtime.stateService.get(this.path);
-            return Bool(fields !== undefined);
-        });
-        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

@@ -1,37 +0,0 @@
-import type { Field, FlexibleProvablePure } from "snarkyjs";
-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 ToFieldable> 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 extends ToFieldable>(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

@@ -1 +0,0 @@
-{"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/dist/state/StateMap.js

@@ -1,56 +0,0 @@
-import { Path } from "@proto-kit/protocol";
-import { Mixin } from "ts-mixer";
-import { State, WithRuntime, WithPath } from "./State.js";
-/**
- * Map-like wrapper for state
- */
-// eslint-disable-next-line new-cap
-export class StateMap extends Mixin(WithPath, WithRuntime) {
-    /**
-     * 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.hasRuntimeOrFail();
-        state.path = this.getPath(key);
-        state.runtime = this.runtime;
-        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.hasRuntimeOrFail();
-        state.path = Path.fromKey(this.path, this.keyType, key);
-        state.runtime = this.runtime;
-        state.set(value);
-    }
-}

package/dist/state/StateServiceProvider.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"StateServiceProvider.d.ts","sourceRoot":"","sources":["../../src/state/StateServiceProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,qBACa,oBAAoB;IAIL,OAAO,CAAC,mBAAmB;IAHrD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA0C;gBAG5C,mBAAmB,EAAE,YAAY;IAGnE,IAAW,YAAY,IAAI,YAAY,CAEtC;IAEM,sBAAsB,CAAC,OAAO,EAAE,YAAY;IAI5C,cAAc;CAGtB"}

package/dist/state/StateServiceProvider.js

@@ -1,34 +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);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { inject, injectable } from "tsyringe";
-let StateServiceProvider = class StateServiceProvider {
-    constructor(currentStateService) {
-        this.currentStateService = currentStateService;
-        this.defaultStateService = this.currentStateService;
-    }
-    get stateService() {
-        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 };