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

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,EAAY,MAAM,MAAM,CAAC;AAMtC;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAevD"}
+{"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

@@ -20,7 +20,10 @@ export function assert(condition, message) {
             if (!executionContext.current().isSimulated) {
                 log.debug("Assertion failed: ", message);
             }
-            executionContext.setStatusMessage(message);
+            const messageString = message !== undefined && typeof message === "function"
+                ? message()
+                : message;
+            executionContext.setStatusMessage(messageString, new Error().stack);
         }
     });
     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,6 +128,10 @@ declare const RuntimeMethodExecutionDataStruct_base: (new (value: {
         transaction: RuntimeTransaction;
         networkState: NetworkState;
     };
+    empty: () => {
+        transaction: RuntimeTransaction;
+        networkState: NetworkState;
+    };
 };
 export declare class RuntimeMethodExecutionDataStruct extends RuntimeMethodExecutionDataStruct_base implements RuntimeMethodExecutionData {
 }
@@ -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,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;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;IAUlB;;;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
@@ -122,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"}

package/dist/state/protocol/ProtocolState.js

@@ -11,12 +11,10 @@ const errors = {
  */
 export function protocolState() {
     return (target, propertyKey) => {
-        // eslint-disable-next-line @typescript-eslint/init-declarations
         let value;
         Object.defineProperty(target, propertyKey, {
             enumerable: true,
             get: function get() {
-                // eslint-disable-next-line max-len
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 const self = this;
                 if (self.name === undefined) {
@@ -25,7 +23,6 @@ export function protocolState() {
                 if (!self.protocol) {
                     throw errors.missingProtocol(self.constructor.name);
                 }
-                // eslint-disable-next-line no-warning-comments
                 // TODO Add Prefix?
                 const path = Path.fromProperty(self.name, propertyKey);
                 if (value) {

package/dist/utils/AppliedBatchHashList.d.ts

@@ -0,0 +1,17 @@
+import { Bool, Field } from "o1js";
+import { AppliedStateTransitionBatch } from "../model/StateTransitionProvableBatch";
+import { DefaultProvableHashList } from "./ProvableHashList";
+/**
+ * A HashList for AppliedSTBatches, that in addition to the default
+ * functionality, checks that the pushed batches are not empty.
+ * If they are, the pushing is skipped.
+ * Note that if the batch has applied: false, the batch still has to be appended
+ * if it has STs inside
+ */
+export declare class AppliedBatchHashList extends DefaultProvableHashList<AppliedStateTransitionBatch> {
+    constructor(commitment: Field);
+    private isNotEmpty;
+    push(value: AppliedStateTransitionBatch): this;
+    pushIf(value: AppliedStateTransitionBatch, condition: Bool): this;
+}
+//# sourceMappingURL=AppliedBatchHashList.d.ts.map

package/dist/utils/AppliedBatchHashList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppliedBatchHashList.d.ts","sourceRoot":"","sources":["../../src/utils/AppliedBatchHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;;;;;GAMG;AACH,qBAAa,oBAAqB,SAAQ,uBAAuB,CAAC,2BAA2B,CAAC;gBACzE,UAAU,EAAE,KAAK;IAIpC,OAAO,CAAC,UAAU;IAIX,IAAI,CAAC,KAAK,EAAE,2BAA2B;IAIvC,MAAM,CAAC,KAAK,EAAE,2BAA2B,EAAE,SAAS,EAAE,IAAI;CAGlE"}

package/dist/utils/AppliedBatchHashList.js

@@ -0,0 +1,24 @@
+import { Field } from "o1js";
+import { AppliedStateTransitionBatch } from "../model/StateTransitionProvableBatch";
+import { DefaultProvableHashList } from "./ProvableHashList";
+/**
+ * A HashList for AppliedSTBatches, that in addition to the default
+ * functionality, checks that the pushed batches are not empty.
+ * If they are, the pushing is skipped.
+ * Note that if the batch has applied: false, the batch still has to be appended
+ * if it has STs inside
+ */
+export class AppliedBatchHashList extends DefaultProvableHashList {
+    constructor(commitment) {
+        super(AppliedStateTransitionBatch, commitment);
+    }
+    isNotEmpty(value) {
+        return value.batchHash.equals(Field(0)).not();
+    }
+    push(value) {
+        return super.pushIf(value, this.isNotEmpty(value));
+    }
+    pushIf(value, condition) {
+        return super.pushIf(value, condition.and(this.isNotEmpty(value)));
+    }
+}

package/dist/utils/MinaPrefixedProvableHashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MinaPrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/MinaPrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,YAAY,EAAE,MAAM,MAAM,CAAC;AAGrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAStD,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wBAAgB,WAAW,IAAI,KAAK,CAEnC;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,GAAE,KAAsB,GACnC,KAAK;CAOT;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,KAAqB,GAAG,KAAK;CAO7E;AAED,qBAAa,4BAA4B,CACvC,KAAK,CACL,SAAQ,gBAAgB,CAAC,KAAK,CAAC;aAGb,MAAM,EAAE,MAAM;gBAD9B,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EACd,MAAM,EAAE,MAAM,EAC9B,kBAAkB,GAAE,KAAgB;IAKtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAKzC;AAED,qBAAa,mBAAoB,SAAQ,4BAA4B,CAAC,KAAK,CAAC;gBACvD,kBAAkB,GAAE,KAAgB;CAGxD"}
+{"version":3,"file":"MinaPrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/MinaPrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,YAAY,EAAE,MAAM,MAAM,CAAC;AAGrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAUtD,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wBAAgB,WAAW,IAAI,KAAK,CAEnC;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,GAAE,KAAsB,GACnC,KAAK;CAOT;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,KAAqB,GAAG,KAAK;CAO7E;AAED,qBAAa,4BAA4B,CACvC,KAAK,CACL,SAAQ,gBAAgB,CAAC,KAAK,CAAC;aAGb,MAAM,EAAE,MAAM;gBAD9B,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EACd,MAAM,EAAE,MAAM,EAC9B,kBAAkB,GAAE,KAAgB;IAKtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAKzC;AAED,qBAAa,mBAAoB,SAAQ,4BAA4B,CAAC,KAAK,CAAC;gBACvD,kBAAkB,GAAE,KAAgB;CAGxD"}

package/dist/utils/MinaPrefixedProvableHashList.js

@@ -2,6 +2,7 @@ import { Field, Poseidon } from "o1js";
 import { hashWithPrefix, prefixToField } from "@proto-kit/common";
 import { ProvableHashList } from "./ProvableHashList";
 function salt(prefix) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return Poseidon.update([Field(0), Field(0), Field(0)], [prefixToField(prefix)]);
 }
 export const MINA_EVENT_PREFIXES = {

package/dist/utils/ProvableHashList.d.ts

@@ -19,7 +19,7 @@ export declare abstract class ProvableHashList<Value> {
     /**
      * @returns Traling hash of the current hashlist.
      */
-    toField(): import("o1js/dist/node/lib/field").Field;
+    toField(): import("o1js/dist/node/lib/provable/field").Field;
 }
 export declare class DefaultProvableHashList<Value> extends ProvableHashList<Value> {
     hash(elements: Field[]): Field;

package/dist/utils/StateTransitionReductionList.d.ts

@@ -3,7 +3,7 @@ import { ProvableReductionHashList } from "./ProvableReductionHashList";
 export declare class StateTransitionReductionList extends ProvableReductionHashList<ProvableStateTransition> {
     push(value: ProvableStateTransition): this;
     pushWithMetadata(value: ProvableStateTransition): {
-        popLast: import("o1js/dist/node/lib/bool").Bool;
+        popLast: import("o1js/dist/node/lib/provable/bool").Bool;
         value: ProvableStateTransition;
     };
 }

package/dist/utils/StateTransitionReductionList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionReductionList.d.ts","sourceRoot":"","sources":["../../src/utils/StateTransitionReductionList.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,uBAAuB,EACvB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,qBAAa,4BAA6B,SAAQ,yBAAyB,CAAC,uBAAuB,CAAC;IAC3F,IAAI,CAAC,KAAK,EAAE,uBAAuB;IAMnC,gBAAgB,CAAC,KAAK,EAAE,uBAAuB;;;;CAyCvD;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}
+{"version":3,"file":"StateTransitionReductionList.d.ts","sourceRoot":"","sources":["../../src/utils/StateTransitionReductionList.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,uBAAuB,EACvB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,qBAAa,4BAA6B,SAAQ,yBAAyB,CAAC,uBAAuB,CAAC;IAC3F,IAAI,CAAC,KAAK,EAAE,uBAAuB;IAMnC,gBAAgB,CAAC,KAAK,EAAE,uBAAuB;;;;CAyCvD;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}

package/dist/utils/StateTransitionReductionList.js

@@ -35,10 +35,10 @@ export class StateTransitionReductionList extends ProvableReductionHashList {
 }
 export function reduceStateTransitions(transitions) {
     const reduced = [];
-    for (const st of transitions) {
+    transitions.forEach((st) => {
         if (reduced.length === 0) {
             reduced.push(st);
-            continue;
+            return;
         }
         const last = reduced.at(-1);
         if (last.path.equals(st.path).toBoolean()) {
@@ -55,6 +55,6 @@ export function reduceStateTransitions(transitions) {
         else {
             reduced.push(st);
         }
-    }
+    });
     return reduced;
 }

package/dist/utils/merkletree/InMemoryMerkleTreeStorage.d.ts

@@ -0,0 +1,11 @@
+import { MerkleTreeStore } from "./MerkleTreeStore";
+export declare class InMemoryMerkleTreeStorage implements MerkleTreeStore {
+    protected nodes: {
+        [key: number]: {
+            [key: string]: bigint;
+        };
+    };
+    getNode(key: bigint, level: number): bigint | undefined;
+    setNode(key: bigint, level: number, value: bigint): void;
+}
+//# sourceMappingURL=InMemoryMerkleTreeStorage.d.ts.map

package/dist/utils/merkletree/InMemoryMerkleTreeStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryMerkleTreeStorage.d.ts","sourceRoot":"","sources":["../../../src/utils/merkletree/InMemoryMerkleTreeStorage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,yBAA0B,YAAW,eAAe;IAC/D,SAAS,CAAC,KAAK,EAAE;QACf,CAAC,GAAG,EAAE,MAAM,GAAG;YACb,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;SACvB,CAAC;KACH,CAAM;IAEA,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAGhE"}

package/dist/utils/merkletree/InMemoryMerkleTreeStorage.js

@@ -0,0 +1,12 @@
+export class InMemoryMerkleTreeStorage {
+    constructor() {
+        this.nodes = {};
+    }
+    getNode(key, level) {
+        return this.nodes[level]?.[key.toString()];
+    }
+    setNode(key, level, value) {
+        var _a;
+        ((_a = this.nodes)[level] ?? (_a[level] = {}))[key.toString()] = value;
+    }
+}

package/dist/utils/merkletree/MerkleTreeStore.d.ts

@@ -0,0 +1,5 @@
+export interface MerkleTreeStore {
+    setNode: (key: bigint, level: number, value: bigint) => void;
+    getNode: (key: bigint, level: number) => bigint | undefined;
+}
+//# sourceMappingURL=MerkleTreeStore.d.ts.map

package/dist/utils/merkletree/MerkleTreeStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MerkleTreeStore.d.ts","sourceRoot":"","sources":["../../../src/utils/merkletree/MerkleTreeStore.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE7D,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC7D"}

package/dist/utils/merkletree/MerkleTreeStore.js

@@ -0,0 +1 @@
+export {};