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

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

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

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

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

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

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

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

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

@@ -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"}