@proto-kit/protocol 0.1.1-develop.600 → 0.1.1-develop.833

package/dist/settlement/messages/Withdrawal.js

@@ -0,0 +1,13 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+import { EMPTY_PUBLICKEY } from "@proto-kit/common";
+export class Withdrawal extends Struct({
+    address: PublicKey,
+    amount: UInt64,
+}) {
+    static dummy() {
+        return new Withdrawal({
+            address: EMPTY_PUBLICKEY,
+            amount: UInt64.from(0),
+        });
+    }
+}

package/dist/settlement/modularity/ProvableSettlementHook.d.ts

@@ -0,0 +1,24 @@
+import { Field, PublicKey, UInt32 } from "o1js";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { NetworkState } from "../../model/network/NetworkState";
+import type { BlockProof } from "../../prover/block/BlockProver";
+import type { SettlementSmartContract } from "../contracts/SettlementSmartContract";
+export type SettlementStateRecord = {
+    sequencerKey: PublicKey;
+    lastSettlementL1Block: UInt32;
+    stateRoot: Field;
+    networkStateHash: Field;
+    blockHashRoot: Field;
+};
+export type SettlementHookInputs = {
+    blockProof: BlockProof;
+    fromNetworkState: NetworkState;
+    toNetworkState: NetworkState;
+    newPromisedMessagesHash: Field;
+    contractState: SettlementStateRecord;
+    currentL1Block: UInt32;
+};
+export declare abstract class ProvableSettlementHook<Config> extends ProtocolModule<Config> {
+    abstract beforeSettlement(smartContract: SettlementSmartContract, inputs: SettlementHookInputs): Promise<void>;
+}
+//# sourceMappingURL=ProvableSettlementHook.d.ts.map

package/dist/settlement/modularity/ProvableSettlementHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableSettlementHook.d.ts","sourceRoot":"","sources":["../../../src/settlement/modularity/ProvableSettlementHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAEpF,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,SAAS,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;IAE9B,SAAS,EAAE,KAAK,CAAC;IACjB,gBAAgB,EAAE,KAAK,CAAC;IACxB,aAAa,EAAE,KAAK,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,cAAc,EAAE,YAAY,CAAC;IAC7B,uBAAuB,EAAE,KAAK,CAAC;IAC/B,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,8BAAsB,sBAAsB,CAC1C,MAAM,CACN,SAAQ,cAAc,CAAC,MAAM,CAAC;aACd,gBAAgB,CAC9B,aAAa,EAAE,uBAAuB,EACtC,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,IAAI,CAAC;CACjB"}

package/dist/settlement/modularity/ProvableSettlementHook.js

@@ -0,0 +1,3 @@
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+export class ProvableSettlementHook extends ProtocolModule {
+}

package/dist/settlement/modules/NetworkStateSettlementModule.d.ts

@@ -1,11 +1,11 @@
 import { UInt64 } from "o1js";
-import { ProvableSettlementHook, SettlementHookInputs } from "../ProvableSettlementHook";
-import { SettlementContract } from "../SettlementContract";
+import { ProvableSettlementHook, SettlementHookInputs } from "../modularity/ProvableSettlementHook";
+import { SettlementSmartContract } from "../contracts/SettlementSmartContract";
 type NetworkStateSettlementModuleConfig = {
     blocksPerL1Block: UInt64;
 };
 export declare class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
-    beforeSettlement(smartContract: SettlementContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }: SettlementHookInputs): void;
+    beforeSettlement(smartContract: SettlementSmartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }: SettlementHookInputs): Promise<void>;
 }
 export {};
 //# sourceMappingURL=NetworkStateSettlementModule.d.ts.map

package/dist/settlement/modules/NetworkStateSettlementModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkStateSettlementModule.d.ts","sourceRoot":"","sources":["../../../src/settlement/modules/NetworkStateSettlementModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAE9B,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,KAAK,kCAAkC,GAAG;IACxC,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,qBAAa,4BAA6B,SAAQ,sBAAsB,CAAC,kCAAkC,CAAC;IACnG,gBAAgB,CACrB,aAAa,EAAE,kBAAkB,EACjC,EACE,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,cAAc,GACf,EAAE,oBAAoB,GACtB,IAAI;CAgBR"}
+{"version":3,"file":"NetworkStateSettlementModule.d.ts","sourceRoot":"","sources":["../../../src/settlement/modules/NetworkStateSettlementModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAE9B,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAE/E,KAAK,kCAAkC,GAAG;IACxC,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAGF,qBAAa,4BAA6B,SAAQ,sBAAsB,CAAC,kCAAkC,CAAC;IAC7F,gBAAgB,CAC3B,aAAa,EAAE,uBAAuB,EACtC,EACE,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,cAAc,GACf,EAAE,oBAAoB;CAiB1B"}

package/dist/settlement/modules/NetworkStateSettlementModule.js

@@ -1,6 +1,7 @@
-import { ProvableSettlementHook, } from "../ProvableSettlementHook";
+import { ProvableSettlementHook, } from "../modularity/ProvableSettlementHook";
+/* eslint-disable @typescript-eslint/no-unused-vars */
 export class NetworkStateSettlementModule extends ProvableSettlementHook {
-    beforeSettlement(smartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }) {
+    async beforeSettlement(smartContract, { blockProof, fromNetworkState, toNetworkState, contractState, currentL1Block, }) {
         const { lastSettlementL1Block } = contractState;
         const blocksPerL1Block = this.config.blocksPerL1Block.toConstant();
         const numL1Blocks = currentL1Block.sub(lastSettlementL1Block);
@@ -10,3 +11,4 @@ export class NetworkStateSettlementModule extends ProvableSettlementHook {
         // TODO Check within bounds efficiently
     }
 }
+/* eslint-enable @typescript-eslint/no-unused-vars */

package/dist/state/State.d.ts

@@ -14,7 +14,7 @@ export declare class WithStateServiceProvider {
         stateServiceProvider: StateServiceProvider;
     };
 }
-declare const State_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider, false>;
+declare const State_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider>;
 /**
  * Utilities for runtime module state, such as get/set
  */
@@ -28,6 +28,7 @@ export declare class State<Value> extends State_base {
      */
     static from<Value>(valueType: FlexibleProvablePure<Value>): State<Value>;
     constructor(valueType: FlexibleProvablePure<Value>);
+    private stateType;
     /**
      * Returns the state that is currently the current state tree
      * value: The value-fields, or if not state was found, dummy values
@@ -49,7 +50,7 @@ export declare class State<Value> extends State_base {
      *
      * @returns Option representation of the current state.
      */
-    get(): Option<Value>;
+    get(): Promise<Option<Value>>;
     /**
      * Sets a new state value by creating a state transition from
      * the current value to the newly set value.
@@ -61,7 +62,7 @@ export declare class State<Value> extends State_base {
      *
      * @param value - Value to be set as the current state
      */
-    set(value: Value): void;
+    set(value: Value): Promise<void>;
 }
 export {};
 //# sourceMappingURL=State.d.ts.map

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

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

package/dist/state/State.js

@@ -1,5 +1,5 @@
 import { Mixin } from "ts-mixer";
-import { Bool, Provable } from "o1js";
+import { Bool, Provable, Struct } from "o1js";
 import { container } from "tsyringe";
 import { dummyValue } from "@proto-kit/common";
 import { Option } from "../model/Option";
@@ -35,6 +35,11 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
     constructor(valueType) {
         super();
         this.valueType = valueType;
+        this.stateType = class StateType extends Struct({
+            value: this.valueType,
+            isSome: Bool,
+        }) {
+        };
     }
     /**
      * Returns the state that is currently the current state tree
@@ -43,15 +48,17 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      * (Basically, whether the value-fields are dummy values or actual values
      * @private
      */
-    getState() {
+    async getState() {
         this.hasStateServiceOrFail();
         this.hasPathOrFail();
         const { path, stateServiceProvider, valueType } = this;
         const { stateTransitions } = container
             .resolve(RuntimeMethodExecutionContext)
             .current().result;
+        // TODO Use Stateservice for this
         // First try to find a match inside already created stateTransitions
-        const previousMutatingTransitions = stateTransitions.filter((transition) => transition.path.equals(path).and(transition.to.isSome).toBoolean());
+        let previousMutatingTransitions = [];
+        previousMutatingTransitions = stateTransitions.filter((transition) => transition.path.equals(path).and(transition.to.isSome).toBoolean());
         const pmtLength = previousMutatingTransitions.length;
         let value = pmtLength > 0
             ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -61,7 +68,7 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
             return { value, isSome: Bool(true) };
         }
         // If the value is still undefined, look it up in the stateService
-        const fields = stateServiceProvider.stateService.get(path);
+        const fields = await stateServiceProvider.stateService.get(path);
         if (fields) {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             value = valueType.fromFields(fields);
@@ -77,11 +84,10 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      *
      * @returns Optional value of the current state
      */
-    witnessFromState() {
+    async witnessFromState() {
         // get the value from storage, or return a dummy value instead
-        const value = Provable.witness(this.valueType, () => this.getState().value);
-        // check if the value exists in the storage or not
-        const isSome = Provable.witness(Bool, () => this.getState().isSome);
+        // also check if the value exists in the storage or not
+        const { value, isSome } = await Provable.witnessAsync(this.stateType, async () => await this.getState());
         return Option.from(isSome, value, this.valueType);
     }
     /**
@@ -90,8 +96,8 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      *
      * @returns Option representation of the current state.
      */
-    get() {
-        const option = this.witnessFromState();
+    async get() {
+        const option = await this.witnessFromState();
         this.hasPathOrFail();
         const stateTransition = StateTransition.from(this.path, option);
         container
@@ -110,9 +116,9 @@ export class State extends Mixin(WithPath, WithStateServiceProvider) {
      *
      * @param value - Value to be set as the current state
      */
-    set(value) {
+    async set(value) {
         // link the transition to the current state
-        const fromOption = this.witnessFromState();
+        const fromOption = await this.witnessFromState();
         const toOption = Option.fromValue(value, this.valueType);
         this.hasPathOrFail();
         const stateTransition = StateTransition.fromTo(this.path, fromOption, toOption);

package/dist/state/StateMap.d.ts

@@ -1,7 +1,7 @@
 import type { Field, FlexibleProvablePure } from "o1js";
 import { Option } from "../model/Option";
 import { WithStateServiceProvider, WithPath } from "./State";
-declare const StateMap_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider, false>;
+declare const StateMap_base: import("ts-mixer/dist/types/types").Class<any[], WithPath & WithStateServiceProvider, typeof WithPath & typeof WithStateServiceProvider>;
 /**
  * Map-like wrapper for state
  */
@@ -24,14 +24,14 @@ export declare class StateMap<KeyType, ValueType> extends StateMap_base {
      * @param key - Key to obtain the state for
      * @returns Value for the provided key.
      */
-    get(key: KeyType): Option<ValueType>;
+    get(key: KeyType): Promise<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;
+    set(key: KeyType, value: ValueType): Promise<void>;
 }
 export {};
 //# sourceMappingURL=StateMap.d.ts.map

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,MAAM,CAAC;AAIxD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAS,wBAAwB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;;AAEpE;;GAEG;AAEH,qBAAa,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAE,SAAQ,aAGjD;IAgBU,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAhBnD;;;;;;OAMG;WACW,IAAI,CAAC,OAAO,EAAE,SAAS,EACnC,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC,GACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;gBAKtB,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAK5C,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK;IAKnC;;;;;OAKG;IACI,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC;IAU3C;;;;;OAKG;IACI,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI;CASjD"}
+{"version":3,"file":"StateMap.d.ts","sourceRoot":"","sources":["../../src/state/StateMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,MAAM,CAAC;AAIxD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAS,wBAAwB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;;AAEpE;;GAEG;AACH,qBAAa,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAE,SAAQ,aAGjD;IAgBU,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAhBnD;;;;;;OAMG;WACW,IAAI,CAAC,OAAO,EAAE,SAAS,EACnC,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC,GACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;gBAKtB,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAK5C,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK;IAKnC;;;;;OAKG;IACU,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAU1D;;;;;OAKG;IACU,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAShE"}

package/dist/state/StateMap.js

@@ -4,7 +4,6 @@ import { State, WithStateServiceProvider, WithPath } from "./State";
 /**
  * Map-like wrapper for state
  */
-// eslint-disable-next-line new-cap
 export class StateMap extends Mixin(WithPath, WithStateServiceProvider) {
     /**
      * Create a new state map with the given key and value types
@@ -31,13 +30,13 @@ export class StateMap extends Mixin(WithPath, WithStateServiceProvider) {
      * @param key - Key to obtain the state for
      * @returns Value for the provided key.
      */
-    get(key) {
+    async get(key) {
         const state = State.from(this.valueType);
         this.hasPathOrFail();
         this.hasStateServiceOrFail();
         state.path = this.getPath(key);
         state.stateServiceProvider = this.stateServiceProvider;
-        return state.get();
+        return await state.get();
     }
     /**
      * Sets a value for the given key in the current state map.
@@ -45,12 +44,12 @@ export class StateMap extends Mixin(WithPath, WithStateServiceProvider) {
      * @param key - Key to store the value under
      * @param value - Value to be stored under the given key
      */
-    set(key, value) {
+    async set(key, value) {
         const state = State.from(this.valueType);
         this.hasPathOrFail();
         this.hasStateServiceOrFail();
         state.path = Path.fromKey(this.path, this.keyType, key);
         state.stateServiceProvider = this.stateServiceProvider;
-        state.set(value);
+        return await state.set(value);
     }
 }

package/dist/state/StateService.d.ts

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

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

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

package/dist/state/StateServiceProvider.d.ts

@@ -1,8 +1,8 @@
-import { StateService } from "./StateService";
+import { SimpleAsyncStateService } from "./StateService";
 export declare class StateServiceProvider {
     private readonly stateServiceStack;
-    get stateService(): StateService;
-    setCurrentStateService(service: StateService): void;
+    get stateService(): SimpleAsyncStateService;
+    setCurrentStateService(service: SimpleAsyncStateService): void;
     popCurrentStateService(): void;
 }
 //# sourceMappingURL=StateServiceProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"StateServiceProvider.d.ts","sourceRoot":"","sources":["../../src/state/StateServiceProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAU9C,qBACa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsB;IAExD,IAAW,YAAY,IAAI,YAAY,CAQtC;IAEM,sBAAsB,CAAC,OAAO,EAAE,YAAY;IAI5C,sBAAsB;CAO9B"}
+{"version":3,"file":"StateServiceProvider.d.ts","sourceRoot":"","sources":["../../src/state/StateServiceProvider.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AASzD,qBACa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAiC;IAEnE,IAAW,YAAY,IAAI,uBAAuB,CAOjD;IAEM,sBAAsB,CAAC,OAAO,EAAE,uBAAuB;IAIvD,sBAAsB;CAO9B"}

package/dist/state/StateServiceProvider.js

@@ -9,7 +9,7 @@ import { log } from "@proto-kit/common";
 const errors = {
     stateServiceNotSet: () => new Error("StateService has not been set yet. Be sure to either call your runtime or protocol function by creating them with an AppChain or by setting the stateService manually."),
 };
-let StateServiceProvider = class StateServiceProvider {
+export let StateServiceProvider = class StateServiceProvider {
     constructor() {
         this.stateServiceStack = [];
     }
@@ -18,7 +18,6 @@ let StateServiceProvider = class StateServiceProvider {
             throw errors.stateServiceNotSet();
         }
         // Assertion here is ok, because we check that the array is not empty above
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return this.stateServiceStack.at(-1);
     }
     setCurrentStateService(service) {
@@ -35,4 +34,3 @@ let StateServiceProvider = class StateServiceProvider {
 StateServiceProvider = __decorate([
     injectable()
 ], StateServiceProvider);
-export { StateServiceProvider };

package/dist/state/assert/assert.d.ts

@@ -8,5 +8,5 @@ import { Bool } from "o1js";
  * @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;
+export declare function assert(condition: Bool, message?: string | (() => string)): void;
 //# sourceMappingURL=assert.d.ts.map

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

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

package/dist/state/assert/assert.js

@@ -1,3 +1,4 @@
+import { Provable } from "o1js";
 import { container } from "tsyringe";
 import { log } from "@proto-kit/common";
 import { RuntimeMethodExecutionContext } from "../context/RuntimeMethodExecutionContext";
@@ -14,11 +15,16 @@ export function assert(condition, message) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     const previousStatus = executionContext.current().result.status;
     const status = condition.and(previousStatus);
-    if (!condition.toBoolean()) {
-        if (!executionContext.current().isSimulated) {
-            log.debug("Assertion failed: ", message);
+    Provable.asProver(() => {
+        if (!condition.toBoolean()) {
+            if (!executionContext.current().isSimulated) {
+                log.debug("Assertion failed: ", message);
+            }
+            const messageString = message !== undefined && typeof message === "function"
+                ? message()
+                : message;
+            executionContext.setStatusMessage(messageString, new Error().stack);
         }
-        executionContext.setStatusMessage(message);
-    }
+    });
     executionContext.setStatus(status);
 }

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

@@ -1,5 +1,5 @@
-import { TransitionMethodExecutionContext, TransitionMethodExecutionResult } from "./TransitionMethodExecutionContext";
 import { StateTransition } from "../../model/StateTransition";
+import { TransitionMethodExecutionContext, TransitionMethodExecutionResult } from "./TransitionMethodExecutionContext";
 export declare class ProtocolMethodExecutionContext implements TransitionMethodExecutionContext {
     result: TransitionMethodExecutionResult;
     /**

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

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

package/dist/state/context/ProtocolMethodExecutionContext.js

@@ -1,4 +1,4 @@
-import { TransitionMethodExecutionResult } from "./TransitionMethodExecutionContext";
+import { TransitionMethodExecutionResult, } from "./TransitionMethodExecutionContext";
 export class ProtocolMethodExecutionContext {
     constructor() {
         this.result = new TransitionMethodExecutionResult();

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

@@ -7,6 +7,7 @@ export declare class RuntimeProvableMethodExecutionResult extends ProvableMethod
     stateTransitions: StateTransition<any>[];
     status: Bool;
     statusMessage?: string;
+    stackTrace?: string;
 }
 export interface RuntimeMethodExecutionData {
     transaction: RuntimeTransaction;
@@ -23,13 +24,59 @@ declare const RuntimeMethodExecutionDataStruct_base: (new (value: {
 } & Provable<{
     transaction: RuntimeTransaction;
     networkState: NetworkState;
+}, {
+    transaction: {
+        methodId: bigint;
+        argsHash: bigint;
+        nonce: {
+            isSome: boolean;
+            value: any;
+        };
+        sender: {
+            isSome: boolean;
+            value: any;
+        };
+    };
+    networkState: {
+        block: {
+            height: bigint;
+        };
+        previous: {
+            rootHash: bigint;
+        };
+    };
 }> & {
+    fromValue: (value: {
+        transaction: RuntimeTransaction | {
+            methodId: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            argsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            nonce: import("../..").UInt64Option | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: any;
+            };
+            sender: import("../..").PublicKeyOption | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: any;
+            };
+        };
+        networkState: NetworkState | {
+            block: import("../../model/network/NetworkState").CurrentBlock | {
+                height: bigint | import("o1js/dist/node/lib/provable/int").UInt64;
+            };
+            previous: import("../../model/network/NetworkState").PreviousBlock | {
+                rootHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+        };
+    }) => {
+        transaction: RuntimeTransaction;
+        networkState: NetworkState;
+    };
     toInput: (x: {
         transaction: RuntimeTransaction;
         networkState: NetworkState;
     }) => {
-        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
     };
     toJSON: (x: {
         transaction: RuntimeTransaction;
@@ -81,8 +128,12 @@ declare const RuntimeMethodExecutionDataStruct_base: (new (value: {
         transaction: RuntimeTransaction;
         networkState: NetworkState;
     };
+    empty: () => {
+        transaction: RuntimeTransaction;
+        networkState: NetworkState;
+    };
 };
-export declare class RuntimeMethodExecutionDataStruct extends RuntimeMethodExecutionDataStruct_base {
+export declare class RuntimeMethodExecutionDataStruct extends RuntimeMethodExecutionDataStruct_base implements RuntimeMethodExecutionData {
 }
 /**
  * Execution context used to wrap runtime module methods,
@@ -104,7 +155,7 @@ export declare class RuntimeMethodExecutionContext extends ProvableMethodExecuti
     /**
      * @param message - Status message to acompany the current status
      */
-    setStatusMessage(message?: string): void;
+    setStatusMessage(message?: string, stackTrace?: string): void;
     /**
      * @param status - Execution status of the current method
      */

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

@@ -1 +1 @@
-{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/state/context/RuntimeMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAU,MAAM,MAAM,CAAC;AAE9C,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAC3B,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,qBAAa,gCAAiC,SAAQ,qCAGpD;CAAG;AAEL;;;;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,IAAI,gCAAgC;IAYhD,YAAY,CAAC,SAAS,EAAE,OAAO;IAItC;;OAEG;IACI,KAAK;IAIL,WAAW;IASlB;;;OAGG;IACI,OAAO;;;;;;CAQf"}
+{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../../src/state/context/RuntimeMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAU,MAAM,MAAM,CAAC;AAE9C,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAE3B,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;IAC9E,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;IAE9C,MAAM,EAAE,IAAI,CAAc;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,UAAU,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,kBAAkB,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,gCACX,SAAQ,qCAIR,YAAW,0BAA0B;CAAG;AAE1C;;;;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,EAAE,UAAU,CAAC,EAAE,MAAM;IAS7D;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAQ7B;;OAEG;IACI,KAAK,CAAC,KAAK,EAAE,0BAA0B;IAIvC,YAAY,IAAI,gCAAgC;IAYhD,YAAY,CAAC,SAAS,EAAE,OAAO;IAItC;;OAEG;IACI,KAAK;IAIL,WAAW;IAUlB;;;OAGG;IACI,OAAO;;;;;;CAQf"}

package/dist/state/context/RuntimeMethodExecutionContext.js

@@ -15,7 +15,6 @@ const errors = {
 export class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutionResult {
     constructor() {
         super(...arguments);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.stateTransitions = [];
         this.status = Bool(true);
     }
@@ -30,7 +29,7 @@ export class RuntimeMethodExecutionDataStruct extends Struct({
  * allowing them to post relevant information (such as execution status)
  * into the context without any unnecessary 'prop drilling'.
  */
-let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
+export let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
     constructor() {
         super(...arguments);
         this.methods = [];
@@ -53,13 +52,14 @@ let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends
     /**
      * @param message - Status message to acompany the current status
      */
-    setStatusMessage(message) {
-        var _a;
+    setStatusMessage(message, stackTrace) {
+        var _a, _b;
         this.assertSetupCalled();
         if (this.isSimulated) {
             return;
         }
         (_a = this.result).statusMessage ?? (_a.statusMessage = message);
+        (_b = this.result).stackTrace ?? (_b.stackTrace = stackTrace);
     }
     /**
      * @param status - Execution status of the current method
@@ -101,7 +101,8 @@ let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends
         super.afterMethod();
         if (this.isFinished) {
             this.lastInput = this.input;
-            this.input = undefined;
+            // TODO: find out why input isnt set in TransactionFeeHook during assert
+            // this.input = undefined;
             this.isSimulated = false;
         }
     }
@@ -121,4 +122,3 @@ let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends
 RuntimeMethodExecutionContext = __decorate([
     singleton()
 ], RuntimeMethodExecutionContext);
-export { RuntimeMethodExecutionContext };

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

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

package/dist/state/context/TransitionMethodExecutionContext.js

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

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

@@ -0,0 +1,14 @@
+import { RuntimeMethodExecutionData, RuntimeProvableMethodExecutionResult } from "./RuntimeMethodExecutionContext";
+/**
+ * Executed a given function f inside a RuntimeMethodExecutionContext
+ * and retrieves the result along with the return value of f
+ * @param f
+ * @param inputs
+ * @param isAnnotated Whether the execution f is annotated with @runtimeMethod or similar
+ * @param isSimulated
+ */
+export declare function executeWithContext<T>(f: () => T, inputs: RuntimeMethodExecutionData, isAnnotated: boolean, isSimulated: boolean): {
+    result: RuntimeProvableMethodExecutionResult;
+    functionResult: T;
+};
+//# sourceMappingURL=contextExecution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contextExecution.d.ts","sourceRoot":"","sources":["../../../src/state/context/contextExecution.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,0BAA0B,EAC1B,oCAAoC,EACrC,MAAM,iCAAiC,CAAC;AAEzC;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,CAAC,EAAE,MAAM,CAAC,EACV,MAAM,EAAE,0BAA0B,EAClC,WAAW,EAAE,OAAO,EACpB,WAAW,EAAE,OAAO,GACnB;IAAE,MAAM,EAAE,oCAAoC,CAAC;IAAC,cAAc,EAAE,CAAC,CAAA;CAAE,CAwBrE"}

package/dist/state/context/contextExecution.js

@@ -0,0 +1,30 @@
+import { container } from "tsyringe";
+import { RuntimeMethodExecutionContext, } from "./RuntimeMethodExecutionContext";
+/**
+ * Executed a given function f inside a RuntimeMethodExecutionContext
+ * and retrieves the result along with the return value of f
+ * @param f
+ * @param inputs
+ * @param isAnnotated Whether the execution f is annotated with @runtimeMethod or similar
+ * @param isSimulated
+ */
+export function executeWithContext(f, inputs, isAnnotated, isSimulated) {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+    if (!isAnnotated) {
+        executionContext.beforeMethod("", "", []);
+    }
+    // Setup context for potential calls to runtime methods.
+    // With the special case that we set the new networkstate for every hook
+    // We also have to put in a dummy transaction for network.transaction
+    executionContext.setup(inputs);
+    executionContext.setSimulated(isSimulated);
+    const functionResult = f();
+    if (!isAnnotated) {
+        executionContext.afterMethod();
+    }
+    const result = executionContext.current().result;
+    return {
+        result,
+        functionResult,
+    };
+}

package/dist/state/protocol/ProtocolState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProtocolState.d.ts","sourceRoot":"","sources":["../../../src/state/protocol/ProtocolState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAgBzF;;;GAGG;AACH,wBAAgB,aAAa,6HAKZ,MAAM,UAoCtB"}
+{"version":3,"file":"ProtocolState.d.ts","sourceRoot":"","sources":["../../../src/state/protocol/ProtocolState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAgBzF;;;GAGG;AACH,wBAAgB,aAAa,6HAKZ,MAAM,UAiCtB"}