@typeberry/lib 0.4.0 → 0.4.1-0a3acb2

package/index.d.ts

@@ -13,7 +13,11 @@ declare enum TestSuite {
 declare const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
 
 declare const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-declare const DEFAULT_VERSION = GpVersion.V0_7_2;
+/**
+ * Current version is set to track the jam-conformance testing.
+ * Since we are currently at 0.7.1 not 0.7.2, we set our default version accordingly.
+ */
+declare const DEFAULT_VERSION = GpVersion.V0_7_1;
 declare let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 declare let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
 
@@ -85,8 +89,8 @@ declare class Compatibility {
   /**
    * Allows selecting different values for different Gray Paper versions from one record.
    *
-   * @param fallback The default value to return if no value is found for the current.
-   * @param record A record mapping versions to values, checking if the version is greater or equal to the current version.
+   * fallback The default value to return if no value is found for the current.
+   * versions A record mapping versions to values, checking if the version is greater or equal to the current version.
    * @returns The value for the current version, or the default value.
    */
   static selectIfGreaterOrEqual<T>({
@@ -274,7 +278,7 @@ declare const workspacePathFix =
     : () => (p: string) => p;
 
 /**
- * @fileoverview `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
+ * `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
  * specified unique token Token. It means that base type cannot be assigned to unique type by accident.
  * Good examples of opaque types include:
  * - JWTs or other tokens - these are special kinds of string used for authorization purposes.
@@ -431,7 +435,7 @@ declare const Result$2 = {
 // - https://onnxruntime.ai/docs/tutorials/web/large-models.html#maximum-size-of-arraybuffer
 declare const MAX_LENGTH$1 = 2145386496;
 
-declare function safeAllocUint8Array(length: number) {
+declare function safeAllocUint8Array(length: number): Uint8Array {
   if (length > MAX_LENGTH) {
     // biome-ignore lint/suspicious/noConsole: can't have a dependency on logger here
     console.warn(`Trying to allocate ${length} bytes, which is greater than the maximum of ${MAX_LENGTH}.`);
@@ -731,61 +735,61 @@ declare function isResult(x: unknown): x is Result$2<unknown, unknown> {
  * as an afterthought.
  */
 
-declare const index$v_ALL_VERSIONS_IN_ORDER: typeof ALL_VERSIONS_IN_ORDER;
-declare const index$v_CURRENT_SUITE: typeof CURRENT_SUITE;
-declare const index$v_CURRENT_VERSION: typeof CURRENT_VERSION;
-type index$v_Compatibility = Compatibility;
-declare const index$v_Compatibility: typeof Compatibility;
-declare const index$v_DEFAULT_SUITE: typeof DEFAULT_SUITE;
-declare const index$v_DEFAULT_VERSION: typeof DEFAULT_VERSION;
-type index$v_DeepEqualOptions = DeepEqualOptions;
-type index$v_EnumMapping = EnumMapping;
-type index$v_ErrorResult<Error> = ErrorResult<Error>;
-type index$v_ErrorsCollector = ErrorsCollector;
-declare const index$v_ErrorsCollector: typeof ErrorsCollector;
-type index$v_GpVersion = GpVersion;
-declare const index$v_GpVersion: typeof GpVersion;
-type index$v_OK = OK;
-type index$v_OkResult<Ok> = OkResult<Ok>;
-type index$v_Opaque<Type, Token extends string> = Opaque<Type, Token>;
-type index$v_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
-declare const index$v_RichTaggedError: typeof RichTaggedError;
-type index$v_StringLiteral<Type> = StringLiteral<Type>;
-declare const index$v_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
-type index$v_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
-type index$v_TestSuite = TestSuite;
-declare const index$v_TestSuite: typeof TestSuite;
-type index$v_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
-type index$v_Uninstantiable = Uninstantiable;
-type index$v_WithDebug = WithDebug;
-declare const index$v_WithDebug: typeof WithDebug;
-type index$v_WithOpaque<Token extends string> = WithOpaque<Token>;
-declare const index$v___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
-declare const index$v_asOpaqueType: typeof asOpaqueType;
-declare const index$v_assertEmpty: typeof assertEmpty;
-declare const index$v_assertNever: typeof assertNever;
-declare const index$v_callCompareFunction: typeof callCompareFunction;
-declare const index$v_check: typeof check;
-declare const index$v_deepEqual: typeof deepEqual;
-declare const index$v_getAllKeysSorted: typeof getAllKeysSorted;
-declare const index$v_inspect: typeof inspect;
-declare const index$v_isBrowser: typeof isBrowser;
-declare const index$v_isResult: typeof isResult;
-declare const index$v_isTaggedError: typeof isTaggedError;
-declare const index$v_lazyInspect: typeof lazyInspect;
-declare const index$v_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
-declare const index$v_measure: typeof measure;
-declare const index$v_oomWarningPrinted: typeof oomWarningPrinted;
-declare const index$v_parseCurrentSuite: typeof parseCurrentSuite;
-declare const index$v_parseCurrentVersion: typeof parseCurrentVersion;
-declare const index$v_resultToString: typeof resultToString;
-declare const index$v_safeAllocUint8Array: typeof safeAllocUint8Array;
-declare const index$v_seeThrough: typeof seeThrough;
-declare const index$v_trimStack: typeof trimStack;
-declare const index$v_workspacePathFix: typeof workspacePathFix;
-declare namespace index$v {
-  export { index$v_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$v_CURRENT_SUITE as CURRENT_SUITE, index$v_CURRENT_VERSION as CURRENT_VERSION, index$v_Compatibility as Compatibility, index$v_DEFAULT_SUITE as DEFAULT_SUITE, index$v_DEFAULT_VERSION as DEFAULT_VERSION, index$v_ErrorsCollector as ErrorsCollector, index$v_GpVersion as GpVersion, MAX_LENGTH$1 as MAX_LENGTH, Result$2 as Result, index$v_RichTaggedError as RichTaggedError, index$v_TEST_COMPARE_USING as TEST_COMPARE_USING, index$v_TestSuite as TestSuite, index$v_WithDebug as WithDebug, index$v___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$v_asOpaqueType as asOpaqueType, index$v_assertEmpty as assertEmpty, index$v_assertNever as assertNever, index$v_callCompareFunction as callCompareFunction, index$v_check as check, index$v_deepEqual as deepEqual, index$v_getAllKeysSorted as getAllKeysSorted, index$v_inspect as inspect, index$v_isBrowser as isBrowser, index$v_isResult as isResult, index$v_isTaggedError as isTaggedError, index$v_lazyInspect as lazyInspect, index$v_maybeTaggedErrorToString as maybeTaggedErrorToString, index$v_measure as measure, index$v_oomWarningPrinted as oomWarningPrinted, index$v_parseCurrentSuite as parseCurrentSuite, index$v_parseCurrentVersion as parseCurrentVersion, index$v_resultToString as resultToString, index$v_safeAllocUint8Array as safeAllocUint8Array, index$v_seeThrough as seeThrough, index$v_trimStack as trimStack, index$v_workspacePathFix as workspacePathFix };
-  export type { index$v_DeepEqualOptions as DeepEqualOptions, index$v_EnumMapping as EnumMapping, index$v_ErrorResult as ErrorResult, index$v_OK as OK, index$v_OkResult as OkResult, index$v_Opaque as Opaque, index$v_StringLiteral as StringLiteral, index$v_TaggedError as TaggedError, index$v_TokenOf as TokenOf, index$v_Uninstantiable as Uninstantiable, index$v_WithOpaque as WithOpaque };
+declare const index$u_ALL_VERSIONS_IN_ORDER: typeof ALL_VERSIONS_IN_ORDER;
+declare const index$u_CURRENT_SUITE: typeof CURRENT_SUITE;
+declare const index$u_CURRENT_VERSION: typeof CURRENT_VERSION;
+type index$u_Compatibility = Compatibility;
+declare const index$u_Compatibility: typeof Compatibility;
+declare const index$u_DEFAULT_SUITE: typeof DEFAULT_SUITE;
+declare const index$u_DEFAULT_VERSION: typeof DEFAULT_VERSION;
+type index$u_DeepEqualOptions = DeepEqualOptions;
+type index$u_EnumMapping = EnumMapping;
+type index$u_ErrorResult<Error> = ErrorResult<Error>;
+type index$u_ErrorsCollector = ErrorsCollector;
+declare const index$u_ErrorsCollector: typeof ErrorsCollector;
+type index$u_GpVersion = GpVersion;
+declare const index$u_GpVersion: typeof GpVersion;
+type index$u_OK = OK;
+type index$u_OkResult<Ok> = OkResult<Ok>;
+type index$u_Opaque<Type, Token extends string> = Opaque<Type, Token>;
+type index$u_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
+declare const index$u_RichTaggedError: typeof RichTaggedError;
+type index$u_StringLiteral<Type> = StringLiteral<Type>;
+declare const index$u_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
+type index$u_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
+type index$u_TestSuite = TestSuite;
+declare const index$u_TestSuite: typeof TestSuite;
+type index$u_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
+type index$u_Uninstantiable = Uninstantiable;
+type index$u_WithDebug = WithDebug;
+declare const index$u_WithDebug: typeof WithDebug;
+type index$u_WithOpaque<Token extends string> = WithOpaque<Token>;
+declare const index$u___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
+declare const index$u_asOpaqueType: typeof asOpaqueType;
+declare const index$u_assertEmpty: typeof assertEmpty;
+declare const index$u_assertNever: typeof assertNever;
+declare const index$u_callCompareFunction: typeof callCompareFunction;
+declare const index$u_check: typeof check;
+declare const index$u_deepEqual: typeof deepEqual;
+declare const index$u_getAllKeysSorted: typeof getAllKeysSorted;
+declare const index$u_inspect: typeof inspect;
+declare const index$u_isBrowser: typeof isBrowser;
+declare const index$u_isResult: typeof isResult;
+declare const index$u_isTaggedError: typeof isTaggedError;
+declare const index$u_lazyInspect: typeof lazyInspect;
+declare const index$u_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
+declare const index$u_measure: typeof measure;
+declare const index$u_oomWarningPrinted: typeof oomWarningPrinted;
+declare const index$u_parseCurrentSuite: typeof parseCurrentSuite;
+declare const index$u_parseCurrentVersion: typeof parseCurrentVersion;
+declare const index$u_resultToString: typeof resultToString;
+declare const index$u_safeAllocUint8Array: typeof safeAllocUint8Array;
+declare const index$u_seeThrough: typeof seeThrough;
+declare const index$u_trimStack: typeof trimStack;
+declare const index$u_workspacePathFix: typeof workspacePathFix;
+declare namespace index$u {
+  export { index$u_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$u_CURRENT_SUITE as CURRENT_SUITE, index$u_CURRENT_VERSION as CURRENT_VERSION, index$u_Compatibility as Compatibility, index$u_DEFAULT_SUITE as DEFAULT_SUITE, index$u_DEFAULT_VERSION as DEFAULT_VERSION, index$u_ErrorsCollector as ErrorsCollector, index$u_GpVersion as GpVersion, MAX_LENGTH$1 as MAX_LENGTH, Result$2 as Result, index$u_RichTaggedError as RichTaggedError, index$u_TEST_COMPARE_USING as TEST_COMPARE_USING, index$u_TestSuite as TestSuite, index$u_WithDebug as WithDebug, index$u___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$u_asOpaqueType as asOpaqueType, index$u_assertEmpty as assertEmpty, index$u_assertNever as assertNever, index$u_callCompareFunction as callCompareFunction, index$u_check as check, index$u_deepEqual as deepEqual, index$u_getAllKeysSorted as getAllKeysSorted, index$u_inspect as inspect, index$u_isBrowser as isBrowser, index$u_isResult as isResult, index$u_isTaggedError as isTaggedError, index$u_lazyInspect as lazyInspect, index$u_maybeTaggedErrorToString as maybeTaggedErrorToString, index$u_measure as measure, index$u_oomWarningPrinted as oomWarningPrinted, index$u_parseCurrentSuite as parseCurrentSuite, index$u_parseCurrentVersion as parseCurrentVersion, index$u_resultToString as resultToString, index$u_safeAllocUint8Array as safeAllocUint8Array, index$u_seeThrough as seeThrough, index$u_trimStack as trimStack, index$u_workspacePathFix as workspacePathFix };
+  export type { index$u_DeepEqualOptions as DeepEqualOptions, index$u_EnumMapping as EnumMapping, index$u_ErrorResult as ErrorResult, index$u_OK as OK, index$u_OkResult as OkResult, index$u_Opaque as Opaque, index$u_StringLiteral as StringLiteral, index$u_TaggedError as TaggedError, index$u_TokenOf as TokenOf, index$u_Uninstantiable as Uninstantiable, index$u_WithOpaque as WithOpaque };
 }
 
 /** A return value of some comparator. */
@@ -838,14 +842,14 @@ declare class Ordering {
  */
 type Comparator<V> = (self: V, other: V) => Ordering;
 
-type index$u_Comparator<V> = Comparator<V>;
-type index$u_Ordering = Ordering;
-declare const index$u_Ordering: typeof Ordering;
-type index$u_OrderingValue = OrderingValue;
-declare const index$u_OrderingValue: typeof OrderingValue;
-declare namespace index$u {
-  export { index$u_Ordering as Ordering, index$u_OrderingValue as OrderingValue };
-  export type { index$u_Comparator as Comparator };
+type index$t_Comparator<V> = Comparator<V>;
+type index$t_Ordering = Ordering;
+declare const index$t_Ordering: typeof Ordering;
+type index$t_OrderingValue = OrderingValue;
+declare const index$t_OrderingValue: typeof OrderingValue;
+declare namespace index$t {
+  export { index$t_Ordering as Ordering, index$t_OrderingValue as OrderingValue };
+  export type { index$t_Comparator as Comparator };
 }
 
 // TODO: [MaSo] Update BytesBlob and Bytes, so they return Result (not throw error)
@@ -1004,7 +1008,7 @@ declare class BytesBlob {
    *
    * Last chunk might be smaller than `size`.
    */
-  *chunks(size: number): Generator<BytesBlob> {
+  *chunks(size: number): Generator<BytesBlob, undefined, void> {
     for (let i = 0; i < this.length; i += size) {
       yield BytesBlob.blobFrom(this.raw.subarray(i, i + size));
     }
@@ -1239,41 +1243,41 @@ declare class BitVec {
   }
 }
 
-type index$t_BitVec = BitVec;
-declare const index$t_BitVec: typeof BitVec;
-type index$t_Bytes<T extends number> = Bytes<T>;
-declare const index$t_Bytes: typeof Bytes;
-type index$t_BytesBlob = BytesBlob;
-declare const index$t_BytesBlob: typeof BytesBlob;
-declare const index$t_CODE_OF_0: typeof CODE_OF_0;
-declare const index$t_CODE_OF_9: typeof CODE_OF_9;
-declare const index$t_CODE_OF_A: typeof CODE_OF_A;
-declare const index$t_CODE_OF_F: typeof CODE_OF_F;
-declare const index$t_CODE_OF_a: typeof CODE_OF_a;
-declare const index$t_CODE_OF_f: typeof CODE_OF_f;
-declare const index$t_VALUE_OF_A: typeof VALUE_OF_A;
-declare const index$t_byteFromString: typeof byteFromString;
-declare const index$t_bytesBlobComparator: typeof bytesBlobComparator;
-declare const index$t_bytesToHexString: typeof bytesToHexString;
-declare const index$t_numberFromCharCode: typeof numberFromCharCode;
-declare const index$t_u8ArraySameLengthEqual: typeof u8ArraySameLengthEqual;
-declare namespace index$t {
+type index$s_BitVec = BitVec;
+declare const index$s_BitVec: typeof BitVec;
+type index$s_Bytes<T extends number> = Bytes<T>;
+declare const index$s_Bytes: typeof Bytes;
+type index$s_BytesBlob = BytesBlob;
+declare const index$s_BytesBlob: typeof BytesBlob;
+declare const index$s_CODE_OF_0: typeof CODE_OF_0;
+declare const index$s_CODE_OF_9: typeof CODE_OF_9;
+declare const index$s_CODE_OF_A: typeof CODE_OF_A;
+declare const index$s_CODE_OF_F: typeof CODE_OF_F;
+declare const index$s_CODE_OF_a: typeof CODE_OF_a;
+declare const index$s_CODE_OF_f: typeof CODE_OF_f;
+declare const index$s_VALUE_OF_A: typeof VALUE_OF_A;
+declare const index$s_byteFromString: typeof byteFromString;
+declare const index$s_bytesBlobComparator: typeof bytesBlobComparator;
+declare const index$s_bytesToHexString: typeof bytesToHexString;
+declare const index$s_numberFromCharCode: typeof numberFromCharCode;
+declare const index$s_u8ArraySameLengthEqual: typeof u8ArraySameLengthEqual;
+declare namespace index$s {
   export {
-    index$t_BitVec as BitVec,
-    index$t_Bytes as Bytes,
-    index$t_BytesBlob as BytesBlob,
-    index$t_CODE_OF_0 as CODE_OF_0,
-    index$t_CODE_OF_9 as CODE_OF_9,
-    index$t_CODE_OF_A as CODE_OF_A,
-    index$t_CODE_OF_F as CODE_OF_F,
-    index$t_CODE_OF_a as CODE_OF_a,
-    index$t_CODE_OF_f as CODE_OF_f,
-    index$t_VALUE_OF_A as VALUE_OF_A,
-    index$t_byteFromString as byteFromString,
-    index$t_bytesBlobComparator as bytesBlobComparator,
-    index$t_bytesToHexString as bytesToHexString,
-    index$t_numberFromCharCode as numberFromCharCode,
-    index$t_u8ArraySameLengthEqual as u8ArraySameLengthEqual,
+    index$s_BitVec as BitVec,
+    index$s_Bytes as Bytes,
+    index$s_BytesBlob as BytesBlob,
+    index$s_CODE_OF_0 as CODE_OF_0,
+    index$s_CODE_OF_9 as CODE_OF_9,
+    index$s_CODE_OF_A as CODE_OF_A,
+    index$s_CODE_OF_F as CODE_OF_F,
+    index$s_CODE_OF_a as CODE_OF_a,
+    index$s_CODE_OF_f as CODE_OF_f,
+    index$s_VALUE_OF_A as VALUE_OF_A,
+    index$s_byteFromString as byteFromString,
+    index$s_bytesBlobComparator as bytesBlobComparator,
+    index$s_bytesToHexString as bytesToHexString,
+    index$s_numberFromCharCode as numberFromCharCode,
+    index$s_u8ArraySameLengthEqual as u8ArraySameLengthEqual,
   };
 }
 
@@ -1418,37 +1422,37 @@ declare const minU64 = (a: U64, ...values: U64[]): U64 => values.reduce((min, va
 /** Get the biggest value between U64 a and values given as input parameters. */
 declare const maxU64 = (a: U64, ...values: U64[]): U64 => values.reduce((max, value) => (value < max ? max : value), a);
 
-type index$s_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
-declare const index$s_MAX_VALUE_U16: typeof MAX_VALUE_U16;
-declare const index$s_MAX_VALUE_U32: typeof MAX_VALUE_U32;
-declare const index$s_MAX_VALUE_U64: typeof MAX_VALUE_U64;
-declare const index$s_MAX_VALUE_U8: typeof MAX_VALUE_U8;
-type index$s_U16 = U16;
-type index$s_U32 = U32;
-type index$s_U64 = U64;
-type index$s_U8 = U8;
-type index$s_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
-declare const index$s___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
-declare const index$s_asTypedNumber: typeof asTypedNumber;
-declare const index$s_isU16: typeof isU16;
-declare const index$s_isU32: typeof isU32;
-declare const index$s_isU64: typeof isU64;
-declare const index$s_isU8: typeof isU8;
-declare const index$s_leBytesAsU32: typeof leBytesAsU32;
-declare const index$s_maxU64: typeof maxU64;
-declare const index$s_minU64: typeof minU64;
-declare const index$s_sumU32: typeof sumU32;
-declare const index$s_sumU64: typeof sumU64;
-declare const index$s_tryAsU16: typeof tryAsU16;
-declare const index$s_tryAsU32: typeof tryAsU32;
-declare const index$s_tryAsU64: typeof tryAsU64;
-declare const index$s_tryAsU8: typeof tryAsU8;
-declare const index$s_u32AsLeBytes: typeof u32AsLeBytes;
-declare const index$s_u64FromParts: typeof u64FromParts;
-declare const index$s_u64IntoParts: typeof u64IntoParts;
-declare namespace index$s {
-  export { index$s_MAX_VALUE_U16 as MAX_VALUE_U16, index$s_MAX_VALUE_U32 as MAX_VALUE_U32, index$s_MAX_VALUE_U64 as MAX_VALUE_U64, index$s_MAX_VALUE_U8 as MAX_VALUE_U8, index$s___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$s_asTypedNumber as asTypedNumber, index$s_isU16 as isU16, index$s_isU32 as isU32, index$s_isU64 as isU64, index$s_isU8 as isU8, index$s_leBytesAsU32 as leBytesAsU32, index$s_maxU64 as maxU64, index$s_minU64 as minU64, index$s_sumU32 as sumU32, index$s_sumU64 as sumU64, index$s_tryAsU16 as tryAsU16, index$s_tryAsU32 as tryAsU32, index$s_tryAsU64 as tryAsU64, index$s_tryAsU8 as tryAsU8, index$s_u32AsLeBytes as u32AsLeBytes, index$s_u64FromParts as u64FromParts, index$s_u64IntoParts as u64IntoParts };
-  export type { index$s_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$s_U16 as U16, index$s_U32 as U32, index$s_U64 as U64, index$s_U8 as U8, index$s_WithBytesRepresentation as WithBytesRepresentation };
+type index$r_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
+declare const index$r_MAX_VALUE_U16: typeof MAX_VALUE_U16;
+declare const index$r_MAX_VALUE_U32: typeof MAX_VALUE_U32;
+declare const index$r_MAX_VALUE_U64: typeof MAX_VALUE_U64;
+declare const index$r_MAX_VALUE_U8: typeof MAX_VALUE_U8;
+type index$r_U16 = U16;
+type index$r_U32 = U32;
+type index$r_U64 = U64;
+type index$r_U8 = U8;
+type index$r_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
+declare const index$r___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
+declare const index$r_asTypedNumber: typeof asTypedNumber;
+declare const index$r_isU16: typeof isU16;
+declare const index$r_isU32: typeof isU32;
+declare const index$r_isU64: typeof isU64;
+declare const index$r_isU8: typeof isU8;
+declare const index$r_leBytesAsU32: typeof leBytesAsU32;
+declare const index$r_maxU64: typeof maxU64;
+declare const index$r_minU64: typeof minU64;
+declare const index$r_sumU32: typeof sumU32;
+declare const index$r_sumU64: typeof sumU64;
+declare const index$r_tryAsU16: typeof tryAsU16;
+declare const index$r_tryAsU32: typeof tryAsU32;
+declare const index$r_tryAsU64: typeof tryAsU64;
+declare const index$r_tryAsU8: typeof tryAsU8;
+declare const index$r_u32AsLeBytes: typeof u32AsLeBytes;
+declare const index$r_u64FromParts: typeof u64FromParts;
+declare const index$r_u64IntoParts: typeof u64IntoParts;
+declare namespace index$r {
+  export { index$r_MAX_VALUE_U16 as MAX_VALUE_U16, index$r_MAX_VALUE_U32 as MAX_VALUE_U32, index$r_MAX_VALUE_U64 as MAX_VALUE_U64, index$r_MAX_VALUE_U8 as MAX_VALUE_U8, index$r___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$r_asTypedNumber as asTypedNumber, index$r_isU16 as isU16, index$r_isU32 as isU32, index$r_isU64 as isU64, index$r_isU8 as isU8, index$r_leBytesAsU32 as leBytesAsU32, index$r_maxU64 as maxU64, index$r_minU64 as minU64, index$r_sumU32 as sumU32, index$r_sumU64 as sumU64, index$r_tryAsU16 as tryAsU16, index$r_tryAsU32 as tryAsU32, index$r_tryAsU64 as tryAsU64, index$r_tryAsU8 as tryAsU8, index$r_u32AsLeBytes as u32AsLeBytes, index$r_u64FromParts as u64FromParts, index$r_u64IntoParts as u64IntoParts };
+  export type { index$r_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$r_U16 as U16, index$r_U32 as U32, index$r_U64 as U64, index$r_U8 as U8, index$r_WithBytesRepresentation as WithBytesRepresentation };
 }
 
 /** A decoder for some specific type `T` */
@@ -2435,10 +2439,10 @@ type ClassConstructor<T> = {
 type Codec<T> = Encode<T> & Decode<T>;
 
 /** A codec descriptor with extra view. */
-type CodecWithView<T, V> = Codec<T> & {
+interface CodecWithView<T, V> extends Codec<T> {
   /** encoded data view codec. */
   View: Codec<V>;
-};
+}
 
 /**
  * Type descriptor definition.
@@ -3470,53 +3474,53 @@ declare function sequenceViewFixLen<T, V>(
   );
 }
 
-type index$r_ClassConstructor<T> = ClassConstructor<T>;
-type index$r_Codec<T> = Codec<T>;
-type index$r_CodecRecord<T> = CodecRecord<T>;
-type index$r_CodecWithView<T, V> = CodecWithView<T, V>;
-declare const index$r_DEFAULT_START_LENGTH: typeof DEFAULT_START_LENGTH;
-type index$r_Decode<T> = Decode<T>;
-type index$r_Decoder = Decoder;
-declare const index$r_Decoder: typeof Decoder;
-type index$r_DescribedBy<T> = DescribedBy<T>;
-type index$r_Descriptor<T, V = T> = Descriptor<T, V>;
-declare const index$r_Descriptor: typeof Descriptor;
-type index$r_DescriptorRecord<T> = DescriptorRecord<T>;
-type index$r_Encode<T> = Encode<T>;
-type index$r_Encoder = Encoder;
-declare const index$r_Encoder: typeof Encoder;
-type index$r_EndOfDataError = EndOfDataError;
-declare const index$r_EndOfDataError: typeof EndOfDataError;
-type index$r_LengthRange = LengthRange;
-declare const index$r_MASKS: typeof MASKS;
-declare const index$r_MAX_LENGTH: typeof MAX_LENGTH;
-type index$r_ObjectView<T> = ObjectView<T>;
-declare const index$r_ObjectView: typeof ObjectView;
-type index$r_OptionalRecord<T> = OptionalRecord<T>;
-type index$r_PropertyKeys<T> = PropertyKeys<T>;
-type index$r_SequenceView<T, V = T> = SequenceView<T, V>;
-declare const index$r_SequenceView: typeof SequenceView;
-type index$r_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
-type index$r_SizeHint = SizeHint;
-declare const index$r_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
-declare const index$r_TYPICAL_SEQUENCE_LENGTH: typeof TYPICAL_SEQUENCE_LENGTH;
-type index$r_ViewField<T, V> = ViewField<T, V>;
-declare const index$r_ViewField: typeof ViewField;
-type index$r_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
-declare const index$r_addSizeHints: typeof addSizeHints;
-declare const index$r_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
-declare const index$r_exactHint: typeof exactHint;
-declare const index$r_forEachDescriptor: typeof forEachDescriptor;
-declare const index$r_hasUniqueView: typeof hasUniqueView;
-declare const index$r_objectView: typeof objectView;
-declare const index$r_readonlyArray: typeof readonlyArray;
-declare const index$r_sequenceViewFixLen: typeof sequenceViewFixLen;
-declare const index$r_sequenceViewVarLen: typeof sequenceViewVarLen;
-declare const index$r_tryAsExactBytes: typeof tryAsExactBytes;
-declare const index$r_validateLength: typeof validateLength;
-declare namespace index$r {
-  export { index$r_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$r_Decoder as Decoder, index$r_Descriptor as Descriptor, index$r_Encoder as Encoder, index$r_EndOfDataError as EndOfDataError, index$r_MASKS as MASKS, index$r_MAX_LENGTH as MAX_LENGTH, index$r_ObjectView as ObjectView, index$r_SequenceView as SequenceView, index$r_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$r_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$r_ViewField as ViewField, index$r_addSizeHints as addSizeHints, codec$1 as codec, index$r_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$r_exactHint as exactHint, index$r_forEachDescriptor as forEachDescriptor, index$r_hasUniqueView as hasUniqueView, index$r_objectView as objectView, index$r_readonlyArray as readonlyArray, index$r_sequenceViewFixLen as sequenceViewFixLen, index$r_sequenceViewVarLen as sequenceViewVarLen, index$r_tryAsExactBytes as tryAsExactBytes, index$r_validateLength as validateLength };
-  export type { index$r_ClassConstructor as ClassConstructor, index$r_Codec as Codec, index$r_CodecRecord as CodecRecord, index$r_CodecWithView as CodecWithView, index$r_Decode as Decode, index$r_DescribedBy as DescribedBy, index$r_DescriptorRecord as DescriptorRecord, index$r_Encode as Encode, index$r_LengthRange as LengthRange, index$r_OptionalRecord as OptionalRecord, Options$1 as Options, index$r_PropertyKeys as PropertyKeys, index$r_SimpleDescriptorRecord as SimpleDescriptorRecord, index$r_SizeHint as SizeHint, index$r_ViewOf as ViewOf };
+type index$q_ClassConstructor<T> = ClassConstructor<T>;
+type index$q_Codec<T> = Codec<T>;
+type index$q_CodecRecord<T> = CodecRecord<T>;
+type index$q_CodecWithView<T, V> = CodecWithView<T, V>;
+declare const index$q_DEFAULT_START_LENGTH: typeof DEFAULT_START_LENGTH;
+type index$q_Decode<T> = Decode<T>;
+type index$q_Decoder = Decoder;
+declare const index$q_Decoder: typeof Decoder;
+type index$q_DescribedBy<T> = DescribedBy<T>;
+type index$q_Descriptor<T, V = T> = Descriptor<T, V>;
+declare const index$q_Descriptor: typeof Descriptor;
+type index$q_DescriptorRecord<T> = DescriptorRecord<T>;
+type index$q_Encode<T> = Encode<T>;
+type index$q_Encoder = Encoder;
+declare const index$q_Encoder: typeof Encoder;
+type index$q_EndOfDataError = EndOfDataError;
+declare const index$q_EndOfDataError: typeof EndOfDataError;
+type index$q_LengthRange = LengthRange;
+declare const index$q_MASKS: typeof MASKS;
+declare const index$q_MAX_LENGTH: typeof MAX_LENGTH;
+type index$q_ObjectView<T> = ObjectView<T>;
+declare const index$q_ObjectView: typeof ObjectView;
+type index$q_OptionalRecord<T> = OptionalRecord<T>;
+type index$q_PropertyKeys<T> = PropertyKeys<T>;
+type index$q_SequenceView<T, V = T> = SequenceView<T, V>;
+declare const index$q_SequenceView: typeof SequenceView;
+type index$q_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
+type index$q_SizeHint = SizeHint;
+declare const index$q_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
+declare const index$q_TYPICAL_SEQUENCE_LENGTH: typeof TYPICAL_SEQUENCE_LENGTH;
+type index$q_ViewField<T, V> = ViewField<T, V>;
+declare const index$q_ViewField: typeof ViewField;
+type index$q_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
+declare const index$q_addSizeHints: typeof addSizeHints;
+declare const index$q_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
+declare const index$q_exactHint: typeof exactHint;
+declare const index$q_forEachDescriptor: typeof forEachDescriptor;
+declare const index$q_hasUniqueView: typeof hasUniqueView;
+declare const index$q_objectView: typeof objectView;
+declare const index$q_readonlyArray: typeof readonlyArray;
+declare const index$q_sequenceViewFixLen: typeof sequenceViewFixLen;
+declare const index$q_sequenceViewVarLen: typeof sequenceViewVarLen;
+declare const index$q_tryAsExactBytes: typeof tryAsExactBytes;
+declare const index$q_validateLength: typeof validateLength;
+declare namespace index$q {
+  export { index$q_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$q_Decoder as Decoder, index$q_Descriptor as Descriptor, index$q_Encoder as Encoder, index$q_EndOfDataError as EndOfDataError, index$q_MASKS as MASKS, index$q_MAX_LENGTH as MAX_LENGTH, index$q_ObjectView as ObjectView, index$q_SequenceView as SequenceView, index$q_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$q_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$q_ViewField as ViewField, index$q_addSizeHints as addSizeHints, codec$1 as codec, index$q_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$q_exactHint as exactHint, index$q_forEachDescriptor as forEachDescriptor, index$q_hasUniqueView as hasUniqueView, index$q_objectView as objectView, index$q_readonlyArray as readonlyArray, index$q_sequenceViewFixLen as sequenceViewFixLen, index$q_sequenceViewVarLen as sequenceViewVarLen, index$q_tryAsExactBytes as tryAsExactBytes, index$q_validateLength as validateLength };
+  export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_CodecWithView as CodecWithView, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
 }
 
 /**
@@ -3566,6 +3570,497 @@ declare class ArrayView<T> implements Iterable<T> {
   }
 }
 
+/** A map which uses byte blobs as keys */
+declare class BlobDictionary<K extends BytesBlob, V> extends WithDebug {
+  /**
+   * The root node of the dictionary.
+   *
+   * This is the main internal data structure that organizes entries
+   * in a tree-like fashion (array-based nodes up to `mapNodeThreshold`,
+   * map-based nodes beyond it). All insertions, updates, and deletions
+   * operate through this structure.
+   */
+  private root: Node<K, V> = Node.withList();
+
+  /**
+   * Auxiliary map that stores references to the original keys and their values.
+   *
+   * - Overriding a value in the main structure does not replace the original key reference.
+   * - Used for efficient iteration over `keys()`, `values()`, `entries()`, and computing `size`.
+   */
+  private keyvals: Map<K, Leaf<K, V>> = new Map();
+
+  /**
+   * Protected constructor used internally by `BlobDictionary.new`
+   * and `BlobDictionary.fromEntries`.
+   *
+   * This enforces controlled instantiation — users should create instances
+   * through the provided static factory methods instead of calling the
+   * constructor directly.
+   *
+   * @param mapNodeThreshold - The threshold that determines when the dictionary
+   * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+   */
+  protected constructor(private mapNodeThreshold: number) {
+    super();
+  }
+
+  /**
+   * Returns the number of entries in the dictionary.
+   *
+   * The count is derived from the auxiliary `keyvals` map, which stores
+   * all original key references and their associated values. This ensures
+   * that the `size` reflects the actual number of entries, independent of
+   * internal overrides in the main `root` structure.
+   *
+   * @returns The total number of entries in the dictionary.
+   */
+  get size(): number {
+    return this.keyvals.size;
+  }
+
+  [TEST_COMPARE_USING]() {
+    const vals: [K, V][] = Array.from(this);
+    vals.sort((a, b) => a[0].compare(b[0]).value);
+    return vals;
+  }
+
+  /**
+   * Creates an empty `BlobDictionary`.
+   *
+   * @param mapNodeThreshold - The threshold that determines when the dictionary
+   * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+   * Defaults to `0`.
+   *
+   * @returns A new, empty `BlobDictionary` instance.
+   */
+  static new<K extends BytesBlob, V>(mapNodeThreshold = 0) {
+    return new BlobDictionary<K, V>(mapNodeThreshold);
+  }
+
+  /**
+   * Creates a new `BlobDictionary` initialized with the given entries.
+   *
+   * @param entries - An array of `[key, value]` pairs used to populate the dictionary.
+   * @param mapNodeThreshold - The threshold that determines when the dictionary
+   * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+   * Defaults to `0`.
+   *
+   * @returns A new `BlobDictionary` containing the provided entries.
+   */
+  static fromEntries<K extends BytesBlob, V>(entries: [K, V][], mapNodeThreshold?: number): BlobDictionary<K, V> {
+    const dict = BlobDictionary.new<K, V>(mapNodeThreshold);
+    for (const [key, value] of entries) {
+      dict.set(key, value);
+    }
+    return dict;
+  }
+  /**
+   * Internal helper that inserts, updates or deletes an entry in the dictionary.
+   *
+   * Behaviour details:
+   * - Passing `undefined` as `value` indicates a deletion. (E.g. `delete` uses `internalSet(key, undefined)`.)
+   * - When an add (new entry) or a delete actually changes the structure, the method returns the affected leaf node.
+   * - When the call only overrides an existing value (no structural add/delete), the method returns `null`.
+   *
+   * This method is intended for internal use by the dictionary implementation and allows `undefined` as a
+   * sentinel value to signal removals.
+   *
+   * @param key - The key to insert, update or remove.
+   * @param value - The value to associate with the key, or `undefined` to remove the key.
+   * @returns The leaf node created or removed on add/delete, or `null` if the operation only overwrote an existing value.
+   */
+  private internalSet(key: K, value: V | undefined): Leaf<K, V> | null {
+    let node: Node<K, V> = this.root;
+    const keyChunkGenerator = key.chunks(CHUNK_SIZE);
+    let depth = 0;
+
+    for (;;) {
+      const maybeKeyChunk = keyChunkGenerator.next().value;
+      if (maybeKeyChunk === undefined) {
+        if (value === undefined) {
+          return node.remove(key);
+        }
+        return node.set(key, value);
+      }
+
+      const keyChunk: KeyChunk = asOpaqueType(maybeKeyChunk);
+
+      if (node.children instanceof ListChildren) {
+        const subkey = BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE * depth));
+        const leaf = value !== undefined ? node.children.insert(subkey, { key, value }) : node.children.remove(subkey);
+
+        if (subkey.length > CHUNK_SIZE && node.children.children.length > this.mapNodeThreshold) {
+          node.convertListChildrenToMap();
+        }
+        return leaf;
+      }
+
+      depth += 1;
+
+      const children = node.children;
+      if (children instanceof ListChildren) {
+        throw new Error("We handle list node earlier. If we fall through, we know it's for the `Map` case.");
+      }
+
+      if (children instanceof MapChildren) {
+        const maybeNode = children.getChild(keyChunk);
+
+        if (maybeNode !== undefined) {
+          // simply go one level deeper
+          node = maybeNode;
+        } else {
+          // we are trying to remove an item, but it does not exist
+          if (value === undefined) {
+            return null;
+          }
+
+          // no more child nodes, we insert a new one.
+          const newNode = Node.withList<K, V>();
+          children.setChild(keyChunk, newNode);
+          node = newNode;
+        }
+        continue;
+      }
+
+      assertNever(children);
+    }
+  }
+
+  /**
+   * Adds a new entry to the dictionary or updates the value of an existing key.
+   *
+   * If an entry with the given key already exists, its value is replaced
+   * with the new one.
+   *
+   * @param key - The key to add or update in the dictionary.
+   * @param value - The value to associate with the specified key.
+   * @returns Nothing (`void`).
+   */
+  set(key: K, value: V): void {
+    const leaf = this.internalSet(key, value);
+    if (leaf !== null) {
+      this.keyvals.set(leaf.key, leaf);
+    }
+  }
+
+  /**
+   * Retrieves the value associated with the given key from the dictionary.
+   *
+   * If the key does not exist, this method returns `undefined`.
+   *
+   * @param key - The key whose associated value should be retrieved.
+   * @returns The value associated with the specified key, or `undefined` if the key is not present.
+   */
+  get(key: K): V | undefined {
+    let node: MaybeNode<K, V> = this.root;
+    const pathChunksGenerator = key.chunks(CHUNK_SIZE);
+    let depth = 0;
+
+    while (node !== undefined) {
+      const maybePathChunk = pathChunksGenerator.next().value;
+
+      if (node.children instanceof ListChildren) {
+        const subkey = BytesBlob.blobFrom(key.raw.subarray(depth * CHUNK_SIZE));
+        const child = node.children.find(subkey);
+        if (child !== null) {
+          return child.value;
+        }
+      }
+
+      if (maybePathChunk === undefined) {
+        return node.getLeaf()?.value;
+      }
+
+      if (node.children instanceof MapChildren) {
+        const pathChunk: KeyChunk = asOpaqueType(maybePathChunk);
+        node = node.children.getChild(pathChunk);
+        depth += 1;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Checks whether the dictionary contains an entry for the given key.
+   *
+   * ⚠️ **Note:** Avoid using `has(...)` together with `get(...)` in a pattern like this:
+   *
+   * ```ts
+   * if (dict.has(key)) {
+   *   const value = dict.get(key);
+   *   ...
+   * }
+   * ```
+   *
+   * This approach performs two lookups for the same key.
+   *
+   * Instead, prefer the following pattern, which retrieves the value once:
+   *
+   * ```ts
+   * const value = dict.get(key);
+   * if (value !== undefined) {
+   *   ...
+   * }
+   * ```
+   *
+   * @param key - The key to check for.
+   * @returns `true` if the dictionary contains an entry for the given key, otherwise `false`.
+   */
+  has(key: K): boolean {
+    return this.get(key) !== undefined;
+  }
+
+  /**
+   * Removes an entry with the specified key from the dictionary.
+   *
+   * Internally, this calls {@link internalSet} with `undefined` to mark the entry as deleted.
+   *
+   * @param key - The key of the entry to remove.
+   * @returns `true` if an entry was removed (i.e. the key existed), otherwise `false`.
+   */
+  delete(key: K): boolean {
+    const leaf = this.internalSet(key, undefined);
+    if (leaf !== null) {
+      this.keyvals.delete(leaf.key);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Returns an iterator over the keys in the dictionary.
+   *
+   * The iterator yields each key in insertion order.
+   *
+   * @returns An iterator over all keys in the dictionary.
+   */
+  keys(): Iterator<K> & Iterable<K> {
+    return this.keyvals.keys();
+  }
+
+  /**
+   * Returns an iterator over the values in the dictionary.
+   *
+   * The iterator yields each value in insertion order.
+   *
+   * @returns An iterator over all values in the dictionary.
+   */
+  *values(): Iterator<V> & Iterable<V> {
+    for (const leaf of this.keyvals.values()) {
+      yield leaf.value;
+    }
+  }
+
+  /**
+   * Returns an iterator over the `[key, value]` pairs in the dictionary.
+   *
+   * The iterator yields entries in insertion order.
+   *
+   * @returns An iterator over `[key, value]` tuples for each entry in the dictionary.
+   */
+  *entries(): Iterator<[K, V]> & Iterable<[K, V]> {
+    for (const leaf of this.keyvals.values()) {
+      yield [leaf.key, leaf.value];
+    }
+  }
+
+  /**
+   * Default iterator for the dictionary.
+   *
+   * Equivalent to calling {@link entries}.
+   * Enables iteration with `for...of`:
+   *
+   * ```ts
+   * for (const [key, value] of dict) {
+   *   ...
+   * }
+   * ```
+   *
+   * @returns An iterator over `[key, value]` pairs.
+   */
+  [Symbol.iterator](): Iterator<[K, V]> & Iterable<[K, V]> {
+    return this.entries();
+  }
+
+  /**
+   * Creates a new sorted array of values, ordered by their corresponding keys.
+   *
+   * Iterates over all entries in the dictionary and sorts them according
+   * to the provided comparator function applied to the keys.
+   *
+   * @param comparator - A comparator function that can compare two keys.
+   *
+   * @returns A new array containing all values from the dictionary,
+   * sorted according to their keys.
+   */
+  toSortedArray(comparator: Comparator<K>): V[] {
+    const vals: [K, V][] = Array.from(this);
+    vals.sort((a, b) => comparator(a[0], b[0]).value);
+    return vals.map((x) => x[1]);
+  }
+}
+
+declare const CHUNK_SIZE = 6;
+type CHUNK_SIZE = typeof CHUNK_SIZE;
+
+/**
+ * A function to transform a bytes chunk (up to 6 bytes into U48 number)
+ *
+ * Note that it uses 3 additional bits to store length(`value * 8 + len;`),
+ * It is needed to distinguish shorter chunks that have 0s at the end, for example: [1, 2] and [1, 2, 0]
+ * */
+declare function bytesAsU48(bytes: Uint8Array): number {
+  const len = bytes.length;
+
+  check`${len <= CHUNK_SIZE} Length has to be <= ${CHUNK_SIZE}, got: ${len}`;
+
+  let value = bytes[3] | (bytes[2] << 8) | (bytes[1] << 16) | (bytes[0] << 24);
+
+  for (let i = 4; i < bytes.length; i++) {
+    value = value * 256 + bytes[i];
+  }
+
+  return value * 8 + len;
+}
+
+type KeyChunk = Opaque<BytesBlob, `up to ${CHUNK_SIZE} bytes`>;
+type U48 = number;
+type SubKey<_K extends BytesBlob> = BytesBlob;
+type OriginalKeyRef<K> = K;
+type MaybeNode<K extends BytesBlob, V> = Node<K, V> | undefined;
+
+type Leaf<K extends BytesBlob, V> = {
+  key: OriginalKeyRef<K>;
+  value: V;
+};
+
+declare class Node<K extends BytesBlob, V> {
+  convertListChildrenToMap() {
+    if (!(this.children instanceof ListChildren)) {
+      return;
+    }
+    this.children = MapChildren.fromListNode<K, V>(this.children);
+  }
+
+  static withList<K extends BytesBlob, V>(): Node<K, V> {
+    return new Node(undefined, ListChildren.new());
+  }
+
+  static withMap<K extends BytesBlob, V>(): Node<K, V> {
+    return new Node(undefined, MapChildren.new());
+  }
+
+  private constructor(
+    private leaf: Leaf<K, V> | undefined,
+    public children: MapChildren<K, V> | ListChildren<K, V>,
+  ) {}
+
+  getLeaf(): Leaf<K, V> | undefined {
+    return this.leaf;
+  }
+
+  remove(_key: K): Leaf<K, V> | null {
+    if (this.leaf === undefined) {
+      return null;
+    }
+
+    const removedLeaf = this.leaf;
+    this.leaf = undefined;
+    return removedLeaf;
+  }
+
+  set(key: K, value: V): Leaf<K, V> | null {
+    if (this.leaf === undefined) {
+      this.leaf = { key, value };
+      return this.leaf;
+    }
+    this.leaf.value = value;
+    return null;
+  }
+}
+
+declare class ListChildren<K extends BytesBlob, V> {
+  children: [SubKey<K>, Leaf<K, V>][] = [];
+
+  private constructor() {}
+
+  find(key: SubKey<K>): Leaf<K, V> | null {
+    const result = this.children.find((item) => item[0].isEqualTo(key));
+    if (result !== undefined) {
+      return result[1];
+    }
+    return null;
+  }
+
+  remove(key: SubKey<K>): Leaf<K, V> | null {
+    const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+    if (existingIndex >= 0) {
+      const ret = this.children.splice(existingIndex, 1);
+      return ret[0][1];
+    }
+    return null;
+  }
+
+  insert(key: SubKey<K>, leaf: Leaf<K, V>): Leaf<K, V> | null {
+    const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+    if (existingIndex >= 0) {
+      const existing = this.children[existingIndex];
+      existing[1].value = leaf.value;
+      return null;
+    }
+
+    this.children.push([key, leaf]);
+    return leaf;
+  }
+
+  static new<K extends BytesBlob, V>() {
+    return new ListChildren<K, V>();
+  }
+}
+
+declare class MapChildren<K extends BytesBlob, V> {
+  children: Map<U48, Node<K, V>> = new Map();
+
+  private constructor() {}
+
+  static new<K extends BytesBlob, V>(): MapChildren<K, V> {
+    return new MapChildren<K, V>();
+  }
+
+  static fromListNode<K extends BytesBlob, T>(node: ListChildren<K, T>): MapChildren<K, T> {
+    const mapNode = new MapChildren<K, T>();
+
+    for (const [key, leaf] of node.children) {
+      const currentKeyChunk: KeyChunk = asOpaqueType(BytesBlob.blobFrom(key.raw.subarray(0, CHUNK_SIZE)));
+      const subKey = BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE));
+
+      let child = mapNode.getChild(currentKeyChunk);
+
+      if (child === undefined) {
+        child = Node.withList<K, T>();
+        mapNode.setChild(currentKeyChunk, child);
+      }
+
+      const children = child.children as ListChildren<K, T>;
+      children.insert(subKey, leaf);
+    }
+
+    return mapNode;
+  }
+
+  getChild(keyChunk: KeyChunk) {
+    const chunkAsNumber = bytesAsU48(keyChunk.raw);
+    return this.children.get(chunkAsNumber);
+  }
+
+  setChild(keyChunk: KeyChunk, node: Node<K, V>) {
+    const chunkAsNumber = bytesAsU48(keyChunk.raw);
+    this.children.set(chunkAsNumber, node);
+  }
+}
+
 type ITypedArray = Uint8Array | Uint16Array | Uint32Array;
 type IDataType = string | Buffer | ITypedArray;
 
@@ -3737,23 +4232,23 @@ declare namespace keccak {
 // TODO [ToDr] (#213) this should most likely be moved to a separate
 // package to avoid pulling in unnecessary deps.
 
-type index$q_Blake2b = Blake2b;
-declare const index$q_Blake2b: typeof Blake2b;
-type index$q_Blake2bHash = Blake2bHash;
-type index$q_HASH_SIZE = HASH_SIZE;
-type index$q_KeccakHash = KeccakHash;
-type index$q_OpaqueHash = OpaqueHash;
-type index$q_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
-type index$q_TruncatedHash = TruncatedHash;
-type index$q_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
-declare const index$q_WithHash: typeof WithHash;
-type index$q_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
-declare const index$q_WithHashAndBytes: typeof WithHashAndBytes;
-declare const index$q_ZERO_HASH: typeof ZERO_HASH;
-declare const index$q_keccak: typeof keccak;
-declare namespace index$q {
-  export { index$q_Blake2b as Blake2b, index$q_WithHash as WithHash, index$q_WithHashAndBytes as WithHashAndBytes, index$q_ZERO_HASH as ZERO_HASH, index$q_keccak as keccak, zero$1 as zero };
-  export type { index$q_Blake2bHash as Blake2bHash, index$q_HASH_SIZE as HASH_SIZE, index$q_KeccakHash as KeccakHash, index$q_OpaqueHash as OpaqueHash, index$q_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$q_TruncatedHash as TruncatedHash };
+type index$p_Blake2b = Blake2b;
+declare const index$p_Blake2b: typeof Blake2b;
+type index$p_Blake2bHash = Blake2bHash;
+type index$p_HASH_SIZE = HASH_SIZE;
+type index$p_KeccakHash = KeccakHash;
+type index$p_OpaqueHash = OpaqueHash;
+type index$p_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
+type index$p_TruncatedHash = TruncatedHash;
+type index$p_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
+declare const index$p_WithHash: typeof WithHash;
+type index$p_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
+declare const index$p_WithHashAndBytes: typeof WithHashAndBytes;
+declare const index$p_ZERO_HASH: typeof ZERO_HASH;
+declare const index$p_keccak: typeof keccak;
+declare namespace index$p {
+  export { index$p_Blake2b as Blake2b, index$p_WithHash as WithHash, index$p_WithHashAndBytes as WithHashAndBytes, index$p_ZERO_HASH as ZERO_HASH, index$p_keccak as keccak, zero$1 as zero };
+  export type { index$p_Blake2bHash as Blake2bHash, index$p_HASH_SIZE as HASH_SIZE, index$p_KeccakHash as KeccakHash, index$p_OpaqueHash as OpaqueHash, index$p_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$p_TruncatedHash as TruncatedHash };
 }
 
 /** Immutable view of the `HashDictionary`. */
@@ -3766,17 +4261,20 @@ interface ImmutableHashDictionary<K extends OpaqueHash, V> extends Iterable<[K,
   get(key: K): V | undefined;
 
   /** Iterator over keys of the dictionary. */
-  keys(): Generator<K>;
+  keys(): Iterator<K>;
 
   /** Iterator over values of the dictionary. */
-  values(): Generator<V>;
+  values(): Iterator<V>;
 
   /** Returns an array of the map's values, sorted by their corresponding keys */
   toSortedArray(compare: Comparator<K>): V[];
 }
-
-/** A map which uses hashes as keys. */
-declare class HashDictionary<K extends OpaqueHash, V> implements ImmutableHashDictionary<K, V> {
+/**
+ * A map which uses hashes as keys.
+ *
+ * @deprecated
+ * */
+declare class StringHashDictionary<K extends OpaqueHash, V> implements ImmutableHashDictionary<K, V> {
   // TODO [ToDr] [crit] We can't use `TrieHash` directly in the map,
   // because of the way it's being compared. Hence having `string` here.
   // This has to be benchmarked and re-written to a custom map most likely.
@@ -3856,6 +4354,15 @@ declare class HashDictionary<K extends OpaqueHash, V> implements ImmutableHashDi
   }
 }
 
+declare class HashDictionary<K extends OpaqueHash, V>
+  extends BlobDictionary<K, V>
+  implements ImmutableHashDictionary<K, V>
+{
+  constructor() {
+    super(BLOB_DICTIONARY_THRESHOLD);
+  }
+}
+
 /** Immutable version of the HashSet. */
 interface ImmutableHashSet<V extends OpaqueHash> extends Iterable<V> {
   /** Return number of items in the set. */
@@ -4447,7 +4954,14 @@ declare class SortedSet<V> extends SortedArray<V> implements ImmutableSortedSet<
   }
 }
 
-type HashWithZeroedBit<T extends OpaqueHash> = T;
+declare function getTruncatedKey(key: OpaqueHash | TruncatedHash) {
+  // Always return exactly TRUNCATED_HASH_SIZE bytes.
+  if (key.length === TRUNCATED_HASH_SIZE) {
+    return key;
+  }
+
+  return Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+}
 
 /**
  * A collection of hash-based keys (likely `StateKey`s) which ignores
@@ -4462,22 +4976,18 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   static fromEntries<T extends OpaqueHash, V>(
     entries: Iterable<[T | TruncatedHash, V] | readonly [T | TruncatedHash, V]>,
   ): TruncatedHashDictionary<T, V> {
-    /** Copy key bytes of an entry and replace the last one with 0. */
-    const mapped = Array.from(entries).map<[T, V]>(([key, value]) => {
-      const newKey: T = Bytes.zero(HASH_SIZE).asOpaque();
-      newKey.raw.set(key.raw.subarray(0, TRUNCATED_HASH_SIZE));
-      return [newKey, value];
-    });
-    return new TruncatedHashDictionary(HashDictionary.fromEntries(mapped));
+    return new TruncatedHashDictionary(
+      BlobDictionary.fromEntries<TruncatedHash, V>(
+        Array.from(entries).map(([key, value]) => [getTruncatedKey(key), value]),
+        BLOB_DICTIONARY_THRESHOLD,
+      ),
+    );
   }
 
-  /** A truncated key which we re-use to query the dictionary. */
-  private readonly truncatedKey: T = Bytes.zero(HASH_SIZE).asOpaque();
-
-  private constructor(private readonly dict: HashDictionary<HashWithZeroedBit<T>, V>) {}
+  private constructor(private readonly dict: BlobDictionary<TruncatedHash, V>) {}
 
   [TEST_COMPARE_USING]() {
-    return this.dict;
+    return Array.from(this.dict);
   }
 
   /** Return number of items in the dictionary. */
@@ -4486,31 +4996,27 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 
   /** Retrieve a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  get(fullKey: T | TruncatedHash): V | undefined {
-    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-    return this.dict.get(this.truncatedKey);
+  get(key: T | TruncatedHash): V | undefined {
+    const truncatedKey = getTruncatedKey(key);
+    return this.dict.get(truncatedKey);
   }
 
   /** Return true if the key is present in the dictionary */
-  has(fullKey: T | TruncatedHash): boolean {
-    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-
-    return this.dict.has(this.truncatedKey);
+  has(key: T | TruncatedHash): boolean {
+    const truncatedKey = getTruncatedKey(key);
+    return this.dict.has(truncatedKey);
   }
 
   /** Set or update a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  set(fullKey: T | TruncatedHash, value: V) {
-    // NOTE we can't use the the shared key here, since the collection will
-    // store the key for us, hence the copy.
-    const key = Bytes.zero(HASH_SIZE);
-    key.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-    this.dict.set(key.asOpaque(), value);
+  set(key: T | TruncatedHash, value: V) {
+    const truncatedKey = getTruncatedKey(key);
+    this.dict.set(truncatedKey, value);
   }
 
   /** Remove a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-  delete(fullKey: T | TruncatedHash) {
-    this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-    this.dict.delete(this.truncatedKey);
+  delete(key: T | TruncatedHash) {
+    const truncatedKey = getTruncatedKey(key);
+    this.dict.delete(truncatedKey);
   }
 
   /** Iterator over values of the dictionary. */
@@ -4520,9 +5026,7 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
 
   /** Iterator over entries of the dictionary (with truncated keys) */
   *entries(): Generator<[TruncatedHash, V]> {
-    for (const [key, value] of this.dict.entries()) {
-      yield [Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE).asOpaque(), value];
-    }
+    yield* this.dict.entries();
   }
 
   [Symbol.iterator]() {
@@ -4530,37 +5034,55 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 }
 
-type index$p_ArrayView<T> = ArrayView<T>;
-declare const index$p_ArrayView: typeof ArrayView;
-type index$p_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
-declare const index$p_FixedSizeArray: typeof FixedSizeArray;
-type index$p_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
-declare const index$p_HashDictionary: typeof HashDictionary;
-type index$p_HashSet<V extends OpaqueHash> = HashSet<V>;
-declare const index$p_HashSet: typeof HashSet;
-type index$p_HashWithZeroedBit<T extends OpaqueHash> = HashWithZeroedBit<T>;
-type index$p_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
-type index$p_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
-type index$p_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
-type index$p_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
-type index$p_KeyMapper<K> = KeyMapper<K>;
-type index$p_KeyMappers<TKeys extends readonly unknown[]> = KeyMappers<TKeys>;
-type index$p_KnownSize<T, F extends string> = KnownSize<T, F>;
-type index$p_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
-type index$p_KnownSizeId<X> = KnownSizeId<X>;
-type index$p_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
-declare const index$p_MultiMap: typeof MultiMap;
-type index$p_NestedMaps<TKeys extends readonly unknown[], TValue> = NestedMaps<TKeys, TValue>;
-type index$p_SortedArray<V> = SortedArray<V>;
-declare const index$p_SortedArray: typeof SortedArray;
-type index$p_SortedSet<V> = SortedSet<V>;
-declare const index$p_SortedSet: typeof SortedSet;
-type index$p_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
-declare const index$p_TruncatedHashDictionary: typeof TruncatedHashDictionary;
-declare const index$p_asKnownSize: typeof asKnownSize;
-declare namespace index$p {
-  export { index$p_ArrayView as ArrayView, index$p_FixedSizeArray as FixedSizeArray, index$p_HashDictionary as HashDictionary, index$p_HashSet as HashSet, index$p_MultiMap as MultiMap, index$p_SortedArray as SortedArray, index$p_SortedSet as SortedSet, index$p_TruncatedHashDictionary as TruncatedHashDictionary, index$p_asKnownSize as asKnownSize };
-  export type { index$p_HashWithZeroedBit as HashWithZeroedBit, index$p_ImmutableHashDictionary as ImmutableHashDictionary, index$p_ImmutableHashSet as ImmutableHashSet, index$p_ImmutableSortedArray as ImmutableSortedArray, index$p_ImmutableSortedSet as ImmutableSortedSet, index$p_KeyMapper as KeyMapper, index$p_KeyMappers as KeyMappers, index$p_KnownSize as KnownSize, index$p_KnownSizeArray as KnownSizeArray, index$p_KnownSizeId as KnownSizeId, index$p_NestedMaps as NestedMaps };
+type index$o_ArrayView<T> = ArrayView<T>;
+declare const index$o_ArrayView: typeof ArrayView;
+type index$o_BlobDictionary<K extends BytesBlob, V> = BlobDictionary<K, V>;
+declare const index$o_BlobDictionary: typeof BlobDictionary;
+type index$o_CHUNK_SIZE = CHUNK_SIZE;
+type index$o_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
+declare const index$o_FixedSizeArray: typeof FixedSizeArray;
+type index$o_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
+declare const index$o_HashDictionary: typeof HashDictionary;
+type index$o_HashSet<V extends OpaqueHash> = HashSet<V>;
+declare const index$o_HashSet: typeof HashSet;
+type index$o_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
+type index$o_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
+type index$o_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
+type index$o_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
+type index$o_KeyChunk = KeyChunk;
+type index$o_KeyMapper<K> = KeyMapper<K>;
+type index$o_KeyMappers<TKeys extends readonly unknown[]> = KeyMappers<TKeys>;
+type index$o_KnownSize<T, F extends string> = KnownSize<T, F>;
+type index$o_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
+type index$o_KnownSizeId<X> = KnownSizeId<X>;
+type index$o_Leaf<K extends BytesBlob, V> = Leaf<K, V>;
+type index$o_ListChildren<K extends BytesBlob, V> = ListChildren<K, V>;
+declare const index$o_ListChildren: typeof ListChildren;
+type index$o_MapChildren<K extends BytesBlob, V> = MapChildren<K, V>;
+declare const index$o_MapChildren: typeof MapChildren;
+type index$o_MaybeNode<K extends BytesBlob, V> = MaybeNode<K, V>;
+type index$o_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
+declare const index$o_MultiMap: typeof MultiMap;
+type index$o_NestedMaps<TKeys extends readonly unknown[], TValue> = NestedMaps<TKeys, TValue>;
+type index$o_Node<K extends BytesBlob, V> = Node<K, V>;
+declare const index$o_Node: typeof Node;
+type index$o_OriginalKeyRef<K> = OriginalKeyRef<K>;
+type index$o_SortedArray<V> = SortedArray<V>;
+declare const index$o_SortedArray: typeof SortedArray;
+type index$o_SortedSet<V> = SortedSet<V>;
+declare const index$o_SortedSet: typeof SortedSet;
+type index$o_StringHashDictionary<K extends OpaqueHash, V> = StringHashDictionary<K, V>;
+declare const index$o_StringHashDictionary: typeof StringHashDictionary;
+type index$o_SubKey<_K extends BytesBlob> = SubKey<_K>;
+type index$o_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
+declare const index$o_TruncatedHashDictionary: typeof TruncatedHashDictionary;
+type index$o_U48 = U48;
+declare const index$o_asKnownSize: typeof asKnownSize;
+declare const index$o_bytesAsU48: typeof bytesAsU48;
+declare const index$o_getTruncatedKey: typeof getTruncatedKey;
+declare namespace index$o {
+  export { index$o_ArrayView as ArrayView, index$o_BlobDictionary as BlobDictionary, index$o_FixedSizeArray as FixedSizeArray, index$o_HashDictionary as HashDictionary, index$o_HashSet as HashSet, index$o_ListChildren as ListChildren, index$o_MapChildren as MapChildren, index$o_MultiMap as MultiMap, index$o_Node as Node, index$o_SortedArray as SortedArray, index$o_SortedSet as SortedSet, index$o_StringHashDictionary as StringHashDictionary, index$o_TruncatedHashDictionary as TruncatedHashDictionary, index$o_asKnownSize as asKnownSize, index$o_bytesAsU48 as bytesAsU48, index$o_getTruncatedKey as getTruncatedKey };
+  export type { index$o_CHUNK_SIZE as CHUNK_SIZE, index$o_ImmutableHashDictionary as ImmutableHashDictionary, index$o_ImmutableHashSet as ImmutableHashSet, index$o_ImmutableSortedArray as ImmutableSortedArray, index$o_ImmutableSortedSet as ImmutableSortedSet, index$o_KeyChunk as KeyChunk, index$o_KeyMapper as KeyMapper, index$o_KeyMappers as KeyMappers, index$o_KnownSize as KnownSize, index$o_KnownSizeArray as KnownSizeArray, index$o_KnownSizeId as KnownSizeId, index$o_Leaf as Leaf, index$o_MaybeNode as MaybeNode, index$o_NestedMaps as NestedMaps, index$o_OriginalKeyRef as OriginalKeyRef, index$o_SubKey as SubKey, index$o_U48 as U48 };
 }
 
 declare namespace bandersnatch_d_exports {
@@ -4920,32 +5442,32 @@ declare namespace keyDerivation {
   export type { keyDerivation_BandersnatchSecretSeed as BandersnatchSecretSeed, keyDerivation_Ed25519SecretSeed as Ed25519SecretSeed, keyDerivation_KeySeed as KeySeed, keyDerivation_SEED_SIZE as SEED_SIZE };
 }
 
-type index$o_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
-type index$o_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
-type index$o_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
-type index$o_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
-type index$o_BLS_KEY_BYTES = BLS_KEY_BYTES;
-type index$o_BandersnatchKey = BandersnatchKey;
-type index$o_BandersnatchProof = BandersnatchProof;
-type index$o_BandersnatchRingRoot = BandersnatchRingRoot;
-type index$o_BandersnatchSecretSeed = BandersnatchSecretSeed;
-type index$o_BandersnatchVrfSignature = BandersnatchVrfSignature;
-type index$o_BlsKey = BlsKey;
-type index$o_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
-type index$o_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
-type index$o_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
-type index$o_Ed25519Key = Ed25519Key;
-type index$o_Ed25519Pair = Ed25519Pair;
-declare const index$o_Ed25519Pair: typeof Ed25519Pair;
-type index$o_Ed25519SecretSeed = Ed25519SecretSeed;
-type index$o_Ed25519Signature = Ed25519Signature;
-type index$o_SEED_SIZE = SEED_SIZE;
-declare const index$o_bandersnatch: typeof bandersnatch;
-declare const index$o_ed25519: typeof ed25519;
-declare const index$o_keyDerivation: typeof keyDerivation;
-declare namespace index$o {
-  export { index$o_Ed25519Pair as Ed25519Pair, index$o_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$o_ed25519 as ed25519, initAll as initWasm, index$o_keyDerivation as keyDerivation };
-  export type { index$o_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$o_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$o_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$o_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$o_BLS_KEY_BYTES as BLS_KEY_BYTES, index$o_BandersnatchKey as BandersnatchKey, index$o_BandersnatchProof as BandersnatchProof, index$o_BandersnatchRingRoot as BandersnatchRingRoot, index$o_BandersnatchSecretSeed as BandersnatchSecretSeed, index$o_BandersnatchVrfSignature as BandersnatchVrfSignature, index$o_BlsKey as BlsKey, index$o_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$o_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$o_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$o_Ed25519Key as Ed25519Key, index$o_Ed25519SecretSeed as Ed25519SecretSeed, index$o_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$o_SEED_SIZE as SEED_SIZE };
+type index$n_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
+type index$n_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
+type index$n_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
+type index$n_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
+type index$n_BLS_KEY_BYTES = BLS_KEY_BYTES;
+type index$n_BandersnatchKey = BandersnatchKey;
+type index$n_BandersnatchProof = BandersnatchProof;
+type index$n_BandersnatchRingRoot = BandersnatchRingRoot;
+type index$n_BandersnatchSecretSeed = BandersnatchSecretSeed;
+type index$n_BandersnatchVrfSignature = BandersnatchVrfSignature;
+type index$n_BlsKey = BlsKey;
+type index$n_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
+type index$n_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
+type index$n_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
+type index$n_Ed25519Key = Ed25519Key;
+type index$n_Ed25519Pair = Ed25519Pair;
+declare const index$n_Ed25519Pair: typeof Ed25519Pair;
+type index$n_Ed25519SecretSeed = Ed25519SecretSeed;
+type index$n_Ed25519Signature = Ed25519Signature;
+type index$n_SEED_SIZE = SEED_SIZE;
+declare const index$n_bandersnatch: typeof bandersnatch;
+declare const index$n_ed25519: typeof ed25519;
+declare const index$n_keyDerivation: typeof keyDerivation;
+declare namespace index$n {
+  export { index$n_Ed25519Pair as Ed25519Pair, index$n_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$n_ed25519 as ed25519, initAll as initWasm, index$n_keyDerivation as keyDerivation };
+  export type { index$n_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$n_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$n_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$n_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$n_BLS_KEY_BYTES as BLS_KEY_BYTES, index$n_BandersnatchKey as BandersnatchKey, index$n_BandersnatchProof as BandersnatchProof, index$n_BandersnatchRingRoot as BandersnatchRingRoot, index$n_BandersnatchSecretSeed as BandersnatchSecretSeed, index$n_BandersnatchVrfSignature as BandersnatchVrfSignature, index$n_BlsKey as BlsKey, index$n_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$n_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$n_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$n_Ed25519Key as Ed25519Key, index$n_Ed25519SecretSeed as Ed25519SecretSeed, index$n_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$n_SEED_SIZE as SEED_SIZE };
 }
 
 /**
@@ -5135,25 +5657,25 @@ declare enum PvmBackend {
   Ananas = 1,
 }
 
-type index$n_Bootnode = Bootnode;
-declare const index$n_Bootnode: typeof Bootnode;
-type index$n_ChainSpec = ChainSpec;
-declare const index$n_ChainSpec: typeof ChainSpec;
-declare const index$n_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
-declare const index$n_EST_CORES: typeof EST_CORES;
-declare const index$n_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
-declare const index$n_EST_VALIDATORS: typeof EST_VALIDATORS;
-declare const index$n_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
-type index$n_PeerAddress = PeerAddress;
-type index$n_PeerId = PeerId;
-type index$n_PvmBackend = PvmBackend;
-declare const index$n_PvmBackend: typeof PvmBackend;
-declare const index$n_PvmBackendNames: typeof PvmBackendNames;
-declare const index$n_fullChainSpec: typeof fullChainSpec;
-declare const index$n_tinyChainSpec: typeof tinyChainSpec;
-declare namespace index$n {
-  export { index$n_Bootnode as Bootnode, index$n_ChainSpec as ChainSpec, index$n_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$n_EST_CORES as EST_CORES, index$n_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$n_EST_VALIDATORS as EST_VALIDATORS, index$n_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$n_PvmBackend as PvmBackend, index$n_PvmBackendNames as PvmBackendNames, index$n_fullChainSpec as fullChainSpec, index$n_tinyChainSpec as tinyChainSpec };
-  export type { index$n_PeerAddress as PeerAddress, index$n_PeerId as PeerId };
+type index$m_Bootnode = Bootnode;
+declare const index$m_Bootnode: typeof Bootnode;
+type index$m_ChainSpec = ChainSpec;
+declare const index$m_ChainSpec: typeof ChainSpec;
+declare const index$m_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
+declare const index$m_EST_CORES: typeof EST_CORES;
+declare const index$m_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
+declare const index$m_EST_VALIDATORS: typeof EST_VALIDATORS;
+declare const index$m_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
+type index$m_PeerAddress = PeerAddress;
+type index$m_PeerId = PeerId;
+type index$m_PvmBackend = PvmBackend;
+declare const index$m_PvmBackend: typeof PvmBackend;
+declare const index$m_PvmBackendNames: typeof PvmBackendNames;
+declare const index$m_fullChainSpec: typeof fullChainSpec;
+declare const index$m_tinyChainSpec: typeof tinyChainSpec;
+declare namespace index$m {
+  export { index$m_Bootnode as Bootnode, index$m_ChainSpec as ChainSpec, index$m_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$m_EST_CORES as EST_CORES, index$m_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$m_EST_VALIDATORS as EST_VALIDATORS, index$m_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$m_PvmBackend as PvmBackend, index$m_PvmBackendNames as PvmBackendNames, index$m_fullChainSpec as fullChainSpec, index$m_tinyChainSpec as tinyChainSpec };
+  export type { index$m_PeerAddress as PeerAddress, index$m_PeerId as PeerId };
 }
 
 /**
@@ -6959,74 +7481,74 @@ declare function reencodeAsView<T, V>(codec: Descriptor<T, V>, object: T, chainS
   return Decoder.decodeObject(codec.View, encoded, chainSpec);
 }
 
-type index$m_Block = Block;
-declare const index$m_Block: typeof Block;
-type index$m_BlockView = BlockView;
-type index$m_CodeHash = CodeHash;
-type index$m_CoreIndex = CoreIndex;
-type index$m_EntropyHash = EntropyHash;
-type index$m_Epoch = Epoch;
-type index$m_EpochMarker = EpochMarker;
-declare const index$m_EpochMarker: typeof EpochMarker;
-type index$m_EpochMarkerView = EpochMarkerView;
-type index$m_Extrinsic = Extrinsic;
-declare const index$m_Extrinsic: typeof Extrinsic;
-type index$m_ExtrinsicHash = ExtrinsicHash;
-type index$m_ExtrinsicView = ExtrinsicView;
-type index$m_Header = Header;
-declare const index$m_Header: typeof Header;
-type index$m_HeaderHash = HeaderHash;
-type index$m_HeaderView = HeaderView;
-type index$m_HeaderViewWithHash = HeaderViewWithHash;
-declare const index$m_HeaderViewWithHash: typeof HeaderViewWithHash;
-declare const index$m_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
-type index$m_PerEpochBlock<T> = PerEpochBlock<T>;
-type index$m_PerValidator<T> = PerValidator<T>;
-type index$m_SEGMENT_BYTES = SEGMENT_BYTES;
-type index$m_Segment = Segment;
-type index$m_SegmentIndex = SegmentIndex;
-type index$m_ServiceGas = ServiceGas;
-type index$m_ServiceId = ServiceId;
-type index$m_StateRootHash = StateRootHash;
-type index$m_TicketsMarker = TicketsMarker;
-declare const index$m_TicketsMarker: typeof TicketsMarker;
-type index$m_TicketsMarkerView = TicketsMarkerView;
-type index$m_TimeSlot = TimeSlot;
-type index$m_ValidatorIndex = ValidatorIndex;
-type index$m_ValidatorKeys = ValidatorKeys;
-declare const index$m_ValidatorKeys: typeof ValidatorKeys;
-declare const index$m_W_E: typeof W_E;
-declare const index$m_W_S: typeof W_S;
-type index$m_WorkReportHash = WorkReportHash;
-declare const index$m_assurances: typeof assurances;
-declare const index$m_codecPerEpochBlock: typeof codecPerEpochBlock;
-declare const index$m_codecPerValidator: typeof codecPerValidator;
-declare const index$m_disputes: typeof disputes;
-declare const index$m_emptyBlock: typeof emptyBlock;
-declare const index$m_encodeUnsealedHeader: typeof encodeUnsealedHeader;
-declare const index$m_guarantees: typeof guarantees;
-declare const index$m_headerViewWithHashCodec: typeof headerViewWithHashCodec;
-declare const index$m_legacyDescriptor: typeof legacyDescriptor;
-declare const index$m_preimage: typeof preimage;
-declare const index$m_reencodeAsView: typeof reencodeAsView;
-declare const index$m_refineContext: typeof refineContext;
-declare const index$m_tickets: typeof tickets;
-declare const index$m_tryAsCoreIndex: typeof tryAsCoreIndex;
-declare const index$m_tryAsEpoch: typeof tryAsEpoch;
-declare const index$m_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
-declare const index$m_tryAsPerValidator: typeof tryAsPerValidator;
-declare const index$m_tryAsSegmentIndex: typeof tryAsSegmentIndex;
-declare const index$m_tryAsServiceGas: typeof tryAsServiceGas;
-declare const index$m_tryAsServiceId: typeof tryAsServiceId;
-declare const index$m_tryAsTimeSlot: typeof tryAsTimeSlot;
-declare const index$m_tryAsValidatorIndex: typeof tryAsValidatorIndex;
-declare const index$m_workItem: typeof workItem;
-declare const index$m_workPackage: typeof workPackage;
-declare const index$m_workReport: typeof workReport;
-declare const index$m_workResult: typeof workResult;
-declare namespace index$m {
-  export { index$m_Block as Block, index$m_EpochMarker as EpochMarker, index$m_Extrinsic as Extrinsic, index$m_Header as Header, index$m_HeaderViewWithHash as HeaderViewWithHash, index$m_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$m_TicketsMarker as TicketsMarker, index$m_ValidatorKeys as ValidatorKeys, index$m_W_E as W_E, index$m_W_S as W_S, index$m_assurances as assurances, index$m_codecPerEpochBlock as codecPerEpochBlock, index$m_codecPerValidator as codecPerValidator, codec as codecUtils, index$m_disputes as disputes, index$m_emptyBlock as emptyBlock, index$m_encodeUnsealedHeader as encodeUnsealedHeader, index$m_guarantees as guarantees, index$m_headerViewWithHashCodec as headerViewWithHashCodec, index$m_legacyDescriptor as legacyDescriptor, index$m_preimage as preimage, index$m_reencodeAsView as reencodeAsView, index$m_refineContext as refineContext, index$m_tickets as tickets, index$m_tryAsCoreIndex as tryAsCoreIndex, index$m_tryAsEpoch as tryAsEpoch, index$m_tryAsPerEpochBlock as tryAsPerEpochBlock, index$m_tryAsPerValidator as tryAsPerValidator, index$m_tryAsSegmentIndex as tryAsSegmentIndex, index$m_tryAsServiceGas as tryAsServiceGas, index$m_tryAsServiceId as tryAsServiceId, index$m_tryAsTimeSlot as tryAsTimeSlot, index$m_tryAsValidatorIndex as tryAsValidatorIndex, index$m_workItem as workItem, index$m_workPackage as workPackage, index$m_workReport as workReport, index$m_workResult as workResult };
-  export type { index$m_BlockView as BlockView, index$m_CodeHash as CodeHash, index$m_CoreIndex as CoreIndex, index$m_EntropyHash as EntropyHash, index$m_Epoch as Epoch, index$m_EpochMarkerView as EpochMarkerView, index$m_ExtrinsicHash as ExtrinsicHash, index$m_ExtrinsicView as ExtrinsicView, index$m_HeaderHash as HeaderHash, index$m_HeaderView as HeaderView, index$m_PerEpochBlock as PerEpochBlock, index$m_PerValidator as PerValidator, index$m_SEGMENT_BYTES as SEGMENT_BYTES, index$m_Segment as Segment, index$m_SegmentIndex as SegmentIndex, index$m_ServiceGas as ServiceGas, index$m_ServiceId as ServiceId, index$m_StateRootHash as StateRootHash, index$m_TicketsMarkerView as TicketsMarkerView, index$m_TimeSlot as TimeSlot, index$m_ValidatorIndex as ValidatorIndex, index$m_WorkReportHash as WorkReportHash };
+type index$l_Block = Block;
+declare const index$l_Block: typeof Block;
+type index$l_BlockView = BlockView;
+type index$l_CodeHash = CodeHash;
+type index$l_CoreIndex = CoreIndex;
+type index$l_EntropyHash = EntropyHash;
+type index$l_Epoch = Epoch;
+type index$l_EpochMarker = EpochMarker;
+declare const index$l_EpochMarker: typeof EpochMarker;
+type index$l_EpochMarkerView = EpochMarkerView;
+type index$l_Extrinsic = Extrinsic;
+declare const index$l_Extrinsic: typeof Extrinsic;
+type index$l_ExtrinsicHash = ExtrinsicHash;
+type index$l_ExtrinsicView = ExtrinsicView;
+type index$l_Header = Header;
+declare const index$l_Header: typeof Header;
+type index$l_HeaderHash = HeaderHash;
+type index$l_HeaderView = HeaderView;
+type index$l_HeaderViewWithHash = HeaderViewWithHash;
+declare const index$l_HeaderViewWithHash: typeof HeaderViewWithHash;
+declare const index$l_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
+type index$l_PerEpochBlock<T> = PerEpochBlock<T>;
+type index$l_PerValidator<T> = PerValidator<T>;
+type index$l_SEGMENT_BYTES = SEGMENT_BYTES;
+type index$l_Segment = Segment;
+type index$l_SegmentIndex = SegmentIndex;
+type index$l_ServiceGas = ServiceGas;
+type index$l_ServiceId = ServiceId;
+type index$l_StateRootHash = StateRootHash;
+type index$l_TicketsMarker = TicketsMarker;
+declare const index$l_TicketsMarker: typeof TicketsMarker;
+type index$l_TicketsMarkerView = TicketsMarkerView;
+type index$l_TimeSlot = TimeSlot;
+type index$l_ValidatorIndex = ValidatorIndex;
+type index$l_ValidatorKeys = ValidatorKeys;
+declare const index$l_ValidatorKeys: typeof ValidatorKeys;
+declare const index$l_W_E: typeof W_E;
+declare const index$l_W_S: typeof W_S;
+type index$l_WorkReportHash = WorkReportHash;
+declare const index$l_assurances: typeof assurances;
+declare const index$l_codecPerEpochBlock: typeof codecPerEpochBlock;
+declare const index$l_codecPerValidator: typeof codecPerValidator;
+declare const index$l_disputes: typeof disputes;
+declare const index$l_emptyBlock: typeof emptyBlock;
+declare const index$l_encodeUnsealedHeader: typeof encodeUnsealedHeader;
+declare const index$l_guarantees: typeof guarantees;
+declare const index$l_headerViewWithHashCodec: typeof headerViewWithHashCodec;
+declare const index$l_legacyDescriptor: typeof legacyDescriptor;
+declare const index$l_preimage: typeof preimage;
+declare const index$l_reencodeAsView: typeof reencodeAsView;
+declare const index$l_refineContext: typeof refineContext;
+declare const index$l_tickets: typeof tickets;
+declare const index$l_tryAsCoreIndex: typeof tryAsCoreIndex;
+declare const index$l_tryAsEpoch: typeof tryAsEpoch;
+declare const index$l_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
+declare const index$l_tryAsPerValidator: typeof tryAsPerValidator;
+declare const index$l_tryAsSegmentIndex: typeof tryAsSegmentIndex;
+declare const index$l_tryAsServiceGas: typeof tryAsServiceGas;
+declare const index$l_tryAsServiceId: typeof tryAsServiceId;
+declare const index$l_tryAsTimeSlot: typeof tryAsTimeSlot;
+declare const index$l_tryAsValidatorIndex: typeof tryAsValidatorIndex;
+declare const index$l_workItem: typeof workItem;
+declare const index$l_workPackage: typeof workPackage;
+declare const index$l_workReport: typeof workReport;
+declare const index$l_workResult: typeof workResult;
+declare namespace index$l {
+  export { index$l_Block as Block, index$l_EpochMarker as EpochMarker, index$l_Extrinsic as Extrinsic, index$l_Header as Header, index$l_HeaderViewWithHash as HeaderViewWithHash, index$l_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$l_TicketsMarker as TicketsMarker, index$l_ValidatorKeys as ValidatorKeys, index$l_W_E as W_E, index$l_W_S as W_S, index$l_assurances as assurances, index$l_codecPerEpochBlock as codecPerEpochBlock, index$l_codecPerValidator as codecPerValidator, codec as codecUtils, index$l_disputes as disputes, index$l_emptyBlock as emptyBlock, index$l_encodeUnsealedHeader as encodeUnsealedHeader, index$l_guarantees as guarantees, index$l_headerViewWithHashCodec as headerViewWithHashCodec, index$l_legacyDescriptor as legacyDescriptor, index$l_preimage as preimage, index$l_reencodeAsView as reencodeAsView, index$l_refineContext as refineContext, index$l_tickets as tickets, index$l_tryAsCoreIndex as tryAsCoreIndex, index$l_tryAsEpoch as tryAsEpoch, index$l_tryAsPerEpochBlock as tryAsPerEpochBlock, index$l_tryAsPerValidator as tryAsPerValidator, index$l_tryAsSegmentIndex as tryAsSegmentIndex, index$l_tryAsServiceGas as tryAsServiceGas, index$l_tryAsServiceId as tryAsServiceId, index$l_tryAsTimeSlot as tryAsTimeSlot, index$l_tryAsValidatorIndex as tryAsValidatorIndex, index$l_workItem as workItem, index$l_workPackage as workPackage, index$l_workReport as workReport, index$l_workResult as workResult };
+  export type { index$l_BlockView as BlockView, index$l_CodeHash as CodeHash, index$l_CoreIndex as CoreIndex, index$l_EntropyHash as EntropyHash, index$l_Epoch as Epoch, index$l_EpochMarkerView as EpochMarkerView, index$l_ExtrinsicHash as ExtrinsicHash, index$l_ExtrinsicView as ExtrinsicView, index$l_HeaderHash as HeaderHash, index$l_HeaderView as HeaderView, index$l_PerEpochBlock as PerEpochBlock, index$l_PerValidator as PerValidator, index$l_SEGMENT_BYTES as SEGMENT_BYTES, index$l_Segment as Segment, index$l_SegmentIndex as SegmentIndex, index$l_ServiceGas as ServiceGas, index$l_ServiceId as ServiceId, index$l_StateRootHash as StateRootHash, index$l_TicketsMarkerView as TicketsMarkerView, index$l_TimeSlot as TimeSlot, index$l_ValidatorIndex as ValidatorIndex, index$l_WorkReportHash as WorkReportHash };
 }
 
 /** A type that can be read from a JSON-parsed object. */
@@ -7337,21 +7859,21 @@ declare namespace json {
   }
 }
 
-type index$l_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
-type index$l_FromJson<T> = FromJson<T>;
-type index$l_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
-type index$l_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
-type index$l_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
-declare const index$l_NO_KEY: typeof NO_KEY;
-type index$l_ObjectFromJson<T> = ObjectFromJson<T>;
-type index$l_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
-declare const index$l_diffKeys: typeof diffKeys;
-import index$l_json = json;
-declare const index$l_parseFromJson: typeof parseFromJson;
-declare const index$l_parseOrThrow: typeof parseOrThrow;
-declare namespace index$l {
-  export { index$l_NO_KEY as NO_KEY, index$l_diffKeys as diffKeys, index$l_json as json, index$l_parseFromJson as parseFromJson, index$l_parseOrThrow as parseOrThrow };
-  export type { index$l_Builder as Builder, index$l_FromJson as FromJson, index$l_FromJsonOptional as FromJsonOptional, index$l_FromJsonPrimitive as FromJsonPrimitive, index$l_FromJsonWithParser as FromJsonWithParser, index$l_ObjectFromJson as ObjectFromJson, index$l_Parser as Parser };
+type index$k_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
+type index$k_FromJson<T> = FromJson<T>;
+type index$k_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
+type index$k_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
+type index$k_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
+declare const index$k_NO_KEY: typeof NO_KEY;
+type index$k_ObjectFromJson<T> = ObjectFromJson<T>;
+type index$k_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
+declare const index$k_diffKeys: typeof diffKeys;
+import index$k_json = json;
+declare const index$k_parseFromJson: typeof parseFromJson;
+declare const index$k_parseOrThrow: typeof parseOrThrow;
+declare namespace index$k {
+  export { index$k_NO_KEY as NO_KEY, index$k_diffKeys as diffKeys, index$k_json as json, index$k_parseFromJson as parseFromJson, index$k_parseOrThrow as parseOrThrow };
+  export type { index$k_Builder as Builder, index$k_FromJson as FromJson, index$k_FromJsonOptional as FromJsonOptional, index$k_FromJsonPrimitive as FromJsonPrimitive, index$k_FromJsonWithParser as FromJsonWithParser, index$k_ObjectFromJson as ObjectFromJson, index$k_Parser as Parser };
 }
 
 declare namespace fromJson {
@@ -7854,52 +8376,52 @@ declare const blockFromJson = (spec: ChainSpec) =>
     ({ header, extrinsic }) => Block.create({ header, extrinsic }),
   );
 
-type index$k_CamelToSnake<S extends string> = CamelToSnake<S>;
-type index$k_JsonCulprit = JsonCulprit;
-type index$k_JsonEpochMarker = JsonEpochMarker;
-type index$k_JsonFault = JsonFault;
-type index$k_JsonHeader = JsonHeader;
-type index$k_JsonJudgement = JsonJudgement;
-type index$k_JsonObject<T> = JsonObject<T>;
-type index$k_JsonRefineContext = JsonRefineContext;
-type index$k_JsonReportGuarantee = JsonReportGuarantee;
-type index$k_JsonVerdict = JsonVerdict;
-type index$k_JsonWorkExecResult = JsonWorkExecResult;
-type index$k_JsonWorkRefineLoad = JsonWorkRefineLoad;
-type index$k_JsonWorkReport = JsonWorkReport;
-type index$k_JsonWorkResult = JsonWorkResult;
-declare const index$k_bandersnatchVrfSignature: typeof bandersnatchVrfSignature;
-declare const index$k_blockFromJson: typeof blockFromJson;
-declare const index$k_culpritFromJson: typeof culpritFromJson;
-declare const index$k_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
-declare const index$k_epochMark: typeof epochMark;
-declare const index$k_faultFromJson: typeof faultFromJson;
-import index$k_fromJson = fromJson;
-declare const index$k_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
-declare const index$k_getAvailabilityAssuranceFromJson: typeof getAvailabilityAssuranceFromJson;
-declare const index$k_getExtrinsicFromJson: typeof getExtrinsicFromJson;
-declare const index$k_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
-declare const index$k_headerFromJson: typeof headerFromJson;
-declare const index$k_judgementFromJson: typeof judgementFromJson;
-declare const index$k_preimageFromJson: typeof preimageFromJson;
-declare const index$k_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
-declare const index$k_refineContextFromJson: typeof refineContextFromJson;
-declare const index$k_reportGuaranteeFromJson: typeof reportGuaranteeFromJson;
-declare const index$k_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
-declare const index$k_ticket: typeof ticket;
-declare const index$k_ticketEnvelopeFromJson: typeof ticketEnvelopeFromJson;
-declare const index$k_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
-declare const index$k_validatorKeysFromJson: typeof validatorKeysFromJson;
-declare const index$k_validatorSignatureFromJson: typeof validatorSignatureFromJson;
-declare const index$k_verdictFromJson: typeof verdictFromJson;
-declare const index$k_workExecResultFromJson: typeof workExecResultFromJson;
-declare const index$k_workPackageSpecFromJson: typeof workPackageSpecFromJson;
-declare const index$k_workRefineLoadFromJson: typeof workRefineLoadFromJson;
-declare const index$k_workReportFromJson: typeof workReportFromJson;
-declare const index$k_workResultFromJson: typeof workResultFromJson;
-declare namespace index$k {
-  export { index$k_bandersnatchVrfSignature as bandersnatchVrfSignature, index$k_blockFromJson as blockFromJson, index$k_culpritFromJson as culpritFromJson, index$k_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$k_epochMark as epochMark, index$k_faultFromJson as faultFromJson, index$k_fromJson as fromJson, index$k_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$k_getAvailabilityAssuranceFromJson as getAvailabilityAssuranceFromJson, index$k_getExtrinsicFromJson as getExtrinsicFromJson, index$k_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$k_headerFromJson as headerFromJson, index$k_judgementFromJson as judgementFromJson, index$k_preimageFromJson as preimageFromJson, index$k_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$k_refineContextFromJson as refineContextFromJson, index$k_reportGuaranteeFromJson as reportGuaranteeFromJson, index$k_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$k_ticket as ticket, index$k_ticketEnvelopeFromJson as ticketEnvelopeFromJson, index$k_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$k_validatorKeysFromJson as validatorKeysFromJson, index$k_validatorSignatureFromJson as validatorSignatureFromJson, index$k_verdictFromJson as verdictFromJson, index$k_workExecResultFromJson as workExecResultFromJson, index$k_workPackageSpecFromJson as workPackageSpecFromJson, index$k_workRefineLoadFromJson as workRefineLoadFromJson, index$k_workReportFromJson as workReportFromJson, index$k_workResultFromJson as workResultFromJson };
-  export type { index$k_CamelToSnake as CamelToSnake, index$k_JsonCulprit as JsonCulprit, index$k_JsonEpochMarker as JsonEpochMarker, index$k_JsonFault as JsonFault, index$k_JsonHeader as JsonHeader, index$k_JsonJudgement as JsonJudgement, index$k_JsonObject as JsonObject, index$k_JsonRefineContext as JsonRefineContext, index$k_JsonReportGuarantee as JsonReportGuarantee, index$k_JsonVerdict as JsonVerdict, index$k_JsonWorkExecResult as JsonWorkExecResult, index$k_JsonWorkRefineLoad as JsonWorkRefineLoad, index$k_JsonWorkReport as JsonWorkReport, index$k_JsonWorkResult as JsonWorkResult };
+type index$j_CamelToSnake<S extends string> = CamelToSnake<S>;
+type index$j_JsonCulprit = JsonCulprit;
+type index$j_JsonEpochMarker = JsonEpochMarker;
+type index$j_JsonFault = JsonFault;
+type index$j_JsonHeader = JsonHeader;
+type index$j_JsonJudgement = JsonJudgement;
+type index$j_JsonObject<T> = JsonObject<T>;
+type index$j_JsonRefineContext = JsonRefineContext;
+type index$j_JsonReportGuarantee = JsonReportGuarantee;
+type index$j_JsonVerdict = JsonVerdict;
+type index$j_JsonWorkExecResult = JsonWorkExecResult;
+type index$j_JsonWorkRefineLoad = JsonWorkRefineLoad;
+type index$j_JsonWorkReport = JsonWorkReport;
+type index$j_JsonWorkResult = JsonWorkResult;
+declare const index$j_bandersnatchVrfSignature: typeof bandersnatchVrfSignature;
+declare const index$j_blockFromJson: typeof blockFromJson;
+declare const index$j_culpritFromJson: typeof culpritFromJson;
+declare const index$j_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
+declare const index$j_epochMark: typeof epochMark;
+declare const index$j_faultFromJson: typeof faultFromJson;
+import index$j_fromJson = fromJson;
+declare const index$j_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
+declare const index$j_getAvailabilityAssuranceFromJson: typeof getAvailabilityAssuranceFromJson;
+declare const index$j_getExtrinsicFromJson: typeof getExtrinsicFromJson;
+declare const index$j_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
+declare const index$j_headerFromJson: typeof headerFromJson;
+declare const index$j_judgementFromJson: typeof judgementFromJson;
+declare const index$j_preimageFromJson: typeof preimageFromJson;
+declare const index$j_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
+declare const index$j_refineContextFromJson: typeof refineContextFromJson;
+declare const index$j_reportGuaranteeFromJson: typeof reportGuaranteeFromJson;
+declare const index$j_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
+declare const index$j_ticket: typeof ticket;
+declare const index$j_ticketEnvelopeFromJson: typeof ticketEnvelopeFromJson;
+declare const index$j_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
+declare const index$j_validatorKeysFromJson: typeof validatorKeysFromJson;
+declare const index$j_validatorSignatureFromJson: typeof validatorSignatureFromJson;
+declare const index$j_verdictFromJson: typeof verdictFromJson;
+declare const index$j_workExecResultFromJson: typeof workExecResultFromJson;
+declare const index$j_workPackageSpecFromJson: typeof workPackageSpecFromJson;
+declare const index$j_workRefineLoadFromJson: typeof workRefineLoadFromJson;
+declare const index$j_workReportFromJson: typeof workReportFromJson;
+declare const index$j_workResultFromJson: typeof workResultFromJson;
+declare namespace index$j {
+  export { index$j_bandersnatchVrfSignature as bandersnatchVrfSignature, index$j_blockFromJson as blockFromJson, index$j_culpritFromJson as culpritFromJson, index$j_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$j_epochMark as epochMark, index$j_faultFromJson as faultFromJson, index$j_fromJson as fromJson, index$j_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$j_getAvailabilityAssuranceFromJson as getAvailabilityAssuranceFromJson, index$j_getExtrinsicFromJson as getExtrinsicFromJson, index$j_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$j_headerFromJson as headerFromJson, index$j_judgementFromJson as judgementFromJson, index$j_preimageFromJson as preimageFromJson, index$j_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$j_refineContextFromJson as refineContextFromJson, index$j_reportGuaranteeFromJson as reportGuaranteeFromJson, index$j_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$j_ticket as ticket, index$j_ticketEnvelopeFromJson as ticketEnvelopeFromJson, index$j_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$j_validatorKeysFromJson as validatorKeysFromJson, index$j_validatorSignatureFromJson as validatorSignatureFromJson, index$j_verdictFromJson as verdictFromJson, index$j_workExecResultFromJson as workExecResultFromJson, index$j_workPackageSpecFromJson as workPackageSpecFromJson, index$j_workRefineLoadFromJson as workRefineLoadFromJson, index$j_workReportFromJson as workReportFromJson, index$j_workResultFromJson as workResultFromJson };
+  export type { index$j_CamelToSnake as CamelToSnake, index$j_JsonCulprit as JsonCulprit, index$j_JsonEpochMarker as JsonEpochMarker, index$j_JsonFault as JsonFault, index$j_JsonHeader as JsonHeader, index$j_JsonJudgement as JsonJudgement, index$j_JsonObject as JsonObject, index$j_JsonRefineContext as JsonRefineContext, index$j_JsonReportGuarantee as JsonReportGuarantee, index$j_JsonVerdict as JsonVerdict, index$j_JsonWorkExecResult as JsonWorkExecResult, index$j_JsonWorkRefineLoad as JsonWorkRefineLoad, index$j_JsonWorkReport as JsonWorkReport, index$j_JsonWorkResult as JsonWorkResult };
 }
 
 declare function parseBootnode(v: string): Bootnode {
@@ -7911,7 +8433,7 @@ declare function parseBootnode(v: string): Bootnode {
     throw new Error(`Invalid bootnode format, expected: <name>@<ip>:<port>, got: "${v}"`);
   }
 
-  const portNumber = Number.parseInt(port);
+  const portNumber = Number.parseInt(port, 10);
   if (!isU16(portNumber)) {
     throw new Error(`Invalid port number: "${port}"`);
   }
@@ -8147,16 +8669,16 @@ declare class Logger {
   }
 }
 
-type index$j_Level = Level;
-declare const index$j_Level: typeof Level;
-type index$j_Logger = Logger;
-declare const index$j_Logger: typeof Logger;
-declare const index$j_parseLoggerOptions: typeof parseLoggerOptions;
-declare namespace index$j {
+type index$i_Level = Level;
+declare const index$i_Level: typeof Level;
+type index$i_Logger = Logger;
+declare const index$i_Logger: typeof Logger;
+declare const index$i_parseLoggerOptions: typeof parseLoggerOptions;
+declare namespace index$i {
   export {
-    index$j_Level as Level,
-    index$j_Logger as Logger,
-    index$j_parseLoggerOptions as parseLoggerOptions,
+    index$i_Level as Level,
+    index$i_Logger as Logger,
+    index$i_parseLoggerOptions as parseLoggerOptions,
   };
 }
 
@@ -8388,27 +8910,27 @@ declare function isJsonObject(value: JsonValue): value is AnyJsonObject {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-type index$i_AnyJsonObject = AnyJsonObject;
-declare const index$i_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
-declare const index$i_DEV_CONFIG: typeof DEV_CONFIG;
-type index$i_JipChainSpec = JipChainSpec;
-declare const index$i_JipChainSpec: typeof JipChainSpec;
-type index$i_JsonArray = JsonArray;
-type index$i_JsonValue = JsonValue;
-type index$i_KnownChainSpec = KnownChainSpec;
-declare const index$i_KnownChainSpec: typeof KnownChainSpec;
-declare const index$i_NODE_DEFAULTS: typeof NODE_DEFAULTS;
-type index$i_NodeConfiguration = NodeConfiguration;
-declare const index$i_NodeConfiguration: typeof NodeConfiguration;
-declare const index$i_deepMerge: typeof deepMerge;
-declare const index$i_isJsonObject: typeof isJsonObject;
-declare const index$i_knownChainSpecFromJson: typeof knownChainSpecFromJson;
-declare const index$i_loadConfig: typeof loadConfig;
-declare const index$i_parseBootnode: typeof parseBootnode;
-declare const index$i_processQuery: typeof processQuery;
-declare namespace index$i {
-  export { index$i_DEFAULT_CONFIG as DEFAULT_CONFIG, index$i_DEV_CONFIG as DEV_CONFIG, index$i_JipChainSpec as JipChainSpec, index$i_KnownChainSpec as KnownChainSpec, index$i_NODE_DEFAULTS as NODE_DEFAULTS, index$i_NodeConfiguration as NodeConfiguration, index$i_deepMerge as deepMerge, index$i_isJsonObject as isJsonObject, index$i_knownChainSpecFromJson as knownChainSpecFromJson, index$i_loadConfig as loadConfig, logger$2 as logger, index$i_parseBootnode as parseBootnode, index$i_processQuery as processQuery };
-  export type { index$i_AnyJsonObject as AnyJsonObject, index$i_JsonArray as JsonArray, index$i_JsonValue as JsonValue };
+type index$h_AnyJsonObject = AnyJsonObject;
+declare const index$h_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
+declare const index$h_DEV_CONFIG: typeof DEV_CONFIG;
+type index$h_JipChainSpec = JipChainSpec;
+declare const index$h_JipChainSpec: typeof JipChainSpec;
+type index$h_JsonArray = JsonArray;
+type index$h_JsonValue = JsonValue;
+type index$h_KnownChainSpec = KnownChainSpec;
+declare const index$h_KnownChainSpec: typeof KnownChainSpec;
+declare const index$h_NODE_DEFAULTS: typeof NODE_DEFAULTS;
+type index$h_NodeConfiguration = NodeConfiguration;
+declare const index$h_NodeConfiguration: typeof NodeConfiguration;
+declare const index$h_deepMerge: typeof deepMerge;
+declare const index$h_isJsonObject: typeof isJsonObject;
+declare const index$h_knownChainSpecFromJson: typeof knownChainSpecFromJson;
+declare const index$h_loadConfig: typeof loadConfig;
+declare const index$h_parseBootnode: typeof parseBootnode;
+declare const index$h_processQuery: typeof processQuery;
+declare namespace index$h {
+  export { index$h_DEFAULT_CONFIG as DEFAULT_CONFIG, index$h_DEV_CONFIG as DEV_CONFIG, index$h_JipChainSpec as JipChainSpec, index$h_KnownChainSpec as KnownChainSpec, index$h_NODE_DEFAULTS as NODE_DEFAULTS, index$h_NodeConfiguration as NodeConfiguration, index$h_deepMerge as deepMerge, index$h_isJsonObject as isJsonObject, index$h_knownChainSpecFromJson as knownChainSpecFromJson, index$h_loadConfig as loadConfig, logger$2 as logger, index$h_parseBootnode as parseBootnode, index$h_processQuery as processQuery };
+  export type { index$h_AnyJsonObject as AnyJsonObject, index$h_JsonArray as JsonArray, index$h_JsonValue as JsonValue };
 }
 
 /**
@@ -8695,7 +9217,6 @@ declare class LeafNode {
   /**
    * Get the byte length of embedded value.
    *
-   * @remark
    * Note in case this node only contains hash this is going to be 0.
    */
   getValueLength(): number {
@@ -8707,7 +9228,6 @@ declare class LeafNode {
   /**
    * Returns the embedded value.
    *
-   * @remark
    * Note that this is going to be empty for a regular leaf node (i.e. containing a hash).
    */
   getValue(): BytesBlob {
@@ -8718,7 +9238,6 @@ declare class LeafNode {
   /**
    * Returns contained value hash.
    *
-   * @remark
    * Note that for embedded value this is going to be full 0-padded 32 bytes.
    */
   getValueHash(): ValueHash {
@@ -9198,43 +9717,43 @@ declare const bitLookup = [
   [0b00000000, 8],
 ];
 
-type index$h_BranchNode = BranchNode;
-declare const index$h_BranchNode: typeof BranchNode;
-type index$h_InMemoryTrie = InMemoryTrie;
-declare const index$h_InMemoryTrie: typeof InMemoryTrie;
-type index$h_InputKey = InputKey;
-type index$h_LeafNode = LeafNode;
-declare const index$h_LeafNode: typeof LeafNode;
-type index$h_NodeType = NodeType;
-declare const index$h_NodeType: typeof NodeType;
-type index$h_NodesDb = NodesDb;
-declare const index$h_NodesDb: typeof NodesDb;
-declare const index$h_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
-declare const index$h_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
-type index$h_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
-type index$h_TraversedPath = TraversedPath;
-declare const index$h_TraversedPath: typeof TraversedPath;
-type index$h_TrieHasher = TrieHasher;
-type index$h_TrieNode = TrieNode;
-declare const index$h_TrieNode: typeof TrieNode;
-type index$h_TrieNodeHash = TrieNodeHash;
-type index$h_TruncatedStateKey = TruncatedStateKey;
-type index$h_ValueHash = ValueHash;
-type index$h_WriteableNodesDb = WriteableNodesDb;
-declare const index$h_WriteableNodesDb: typeof WriteableNodesDb;
-declare const index$h_bitLookup: typeof bitLookup;
-declare const index$h_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
-declare const index$h_findNodeToReplace: typeof findNodeToReplace;
-declare const index$h_findSharedPrefix: typeof findSharedPrefix;
-declare const index$h_getBit: typeof getBit;
-declare const index$h_leafComparator: typeof leafComparator;
-declare const index$h_parseInputKey: typeof parseInputKey;
-declare const index$h_trieInsert: typeof trieInsert;
-declare const index$h_trieStringify: typeof trieStringify;
-declare const index$h_zero: typeof zero;
-declare namespace index$h {
-  export { index$h_BranchNode as BranchNode, index$h_InMemoryTrie as InMemoryTrie, index$h_LeafNode as LeafNode, index$h_NodeType as NodeType, index$h_NodesDb as NodesDb, index$h_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$h_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$h_TraversedPath as TraversedPath, index$h_TrieNode as TrieNode, index$h_WriteableNodesDb as WriteableNodesDb, index$h_bitLookup as bitLookup, index$h_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$h_findNodeToReplace as findNodeToReplace, index$h_findSharedPrefix as findSharedPrefix, index$h_getBit as getBit, index$h_leafComparator as leafComparator, index$h_parseInputKey as parseInputKey, index$h_trieInsert as trieInsert, index$h_trieStringify as trieStringify, index$h_zero as zero };
-  export type { index$h_InputKey as InputKey, StateKey$1 as StateKey, index$h_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$h_TrieHasher as TrieHasher, index$h_TrieNodeHash as TrieNodeHash, index$h_TruncatedStateKey as TruncatedStateKey, index$h_ValueHash as ValueHash };
+type index$g_BranchNode = BranchNode;
+declare const index$g_BranchNode: typeof BranchNode;
+type index$g_InMemoryTrie = InMemoryTrie;
+declare const index$g_InMemoryTrie: typeof InMemoryTrie;
+type index$g_InputKey = InputKey;
+type index$g_LeafNode = LeafNode;
+declare const index$g_LeafNode: typeof LeafNode;
+type index$g_NodeType = NodeType;
+declare const index$g_NodeType: typeof NodeType;
+type index$g_NodesDb = NodesDb;
+declare const index$g_NodesDb: typeof NodesDb;
+declare const index$g_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
+declare const index$g_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
+type index$g_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
+type index$g_TraversedPath = TraversedPath;
+declare const index$g_TraversedPath: typeof TraversedPath;
+type index$g_TrieHasher = TrieHasher;
+type index$g_TrieNode = TrieNode;
+declare const index$g_TrieNode: typeof TrieNode;
+type index$g_TrieNodeHash = TrieNodeHash;
+type index$g_TruncatedStateKey = TruncatedStateKey;
+type index$g_ValueHash = ValueHash;
+type index$g_WriteableNodesDb = WriteableNodesDb;
+declare const index$g_WriteableNodesDb: typeof WriteableNodesDb;
+declare const index$g_bitLookup: typeof bitLookup;
+declare const index$g_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
+declare const index$g_findNodeToReplace: typeof findNodeToReplace;
+declare const index$g_findSharedPrefix: typeof findSharedPrefix;
+declare const index$g_getBit: typeof getBit;
+declare const index$g_leafComparator: typeof leafComparator;
+declare const index$g_parseInputKey: typeof parseInputKey;
+declare const index$g_trieInsert: typeof trieInsert;
+declare const index$g_trieStringify: typeof trieStringify;
+declare const index$g_zero: typeof zero;
+declare namespace index$g {
+  export { index$g_BranchNode as BranchNode, index$g_InMemoryTrie as InMemoryTrie, index$g_LeafNode as LeafNode, index$g_NodeType as NodeType, index$g_NodesDb as NodesDb, index$g_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$g_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$g_TraversedPath as TraversedPath, index$g_TrieNode as TrieNode, index$g_WriteableNodesDb as WriteableNodesDb, index$g_bitLookup as bitLookup, index$g_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$g_findNodeToReplace as findNodeToReplace, index$g_findSharedPrefix as findSharedPrefix, index$g_getBit as getBit, index$g_leafComparator as leafComparator, index$g_parseInputKey as parseInputKey, index$g_trieInsert as trieInsert, index$g_trieStringify as trieStringify, index$g_zero as zero };
+  export type { index$g_InputKey as InputKey, StateKey$1 as StateKey, index$g_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$g_TrieHasher as TrieHasher, index$g_TrieNodeHash as TrieNodeHash, index$g_TruncatedStateKey as TruncatedStateKey, index$g_ValueHash as ValueHash };
 }
 
 /**
@@ -9664,16 +10183,16 @@ declare class Mountain<H extends OpaqueHash> {
   }
 }
 
-type index$g_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$g_MerkleMountainRange: typeof MerkleMountainRange;
-type index$g_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$g_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-type index$g_Mountain<H extends OpaqueHash> = Mountain<H>;
-declare const index$g_Mountain: typeof Mountain;
-declare const index$g_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
-declare namespace index$g {
-  export { index$g_MerkleMountainRange as MerkleMountainRange, index$g_Mountain as Mountain, index$g_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
-  export type { index$g_MmrHasher as MmrHasher, index$g_MmrPeaks as MmrPeaks };
+type index$f_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const index$f_MerkleMountainRange: typeof MerkleMountainRange;
+type index$f_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type index$f_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+type index$f_Mountain<H extends OpaqueHash> = Mountain<H>;
+declare const index$f_Mountain: typeof Mountain;
+declare const index$f_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
+declare namespace index$f {
+  export { index$f_MerkleMountainRange as MerkleMountainRange, index$f_Mountain as Mountain, index$f_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
+  export type { index$f_MmrHasher as MmrHasher, index$f_MmrPeaks as MmrPeaks };
 }
 
 /**
@@ -10777,11 +11296,32 @@ type StateView = {
 };
 
 declare enum UpdatePreimageKind {
-  /** Insert new preimage and optionally update it's lookup history. */
+  /**
+   * Insert new preimage and optionally update it's lookup history.
+   *
+   * Used in: `provide`
+   *
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/383904383904?v=0.7.2
+   */
   Provide = 0,
-  /** Remove a preimage and it's lookup history. */
+  /**
+   * Remove a preimage and it's lookup history.
+   *
+   * Used in: `forget` and `eject`
+   *
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/38c701380202?v=0.7.2
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/379102379302?v=0.7.2
+   */
   Remove = 1,
-  /** update or add lookup history for preimage hash/len to given value. */
+  /**
+   * Update or add lookup history for preimage hash/len to given value.
+   *
+   * Used in: `solicit` and `forget`
+   *
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/382802382802?v=0.7.2
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/384002384b02?v=0.7.2
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/38c60038ea00?v=0.7.2
+   */
   UpdateOrAdd = 2,
 }
 /**
@@ -10789,7 +11329,7 @@ declare enum UpdatePreimageKind {
  *
  * Can be one of the following cases:
  * 1. Provide a new preimage blob and set the lookup history to available at `slot`.
- * 2. Remove (expunge) a preimage and it's lookup history.
+ * 2. Remove (forget) a preimage and it's lookup history.
  * 3. Update `LookupHistory` with given value.
  */
 declare class UpdatePreimage {
@@ -11560,123 +12100,123 @@ type FieldNames<T> = {
   [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-type index$f_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
-type index$f_AccumulationOutput = AccumulationOutput;
-declare const index$f_AccumulationOutput: typeof AccumulationOutput;
-type index$f_AccumulationQueue = AccumulationQueue;
-type index$f_AccumulationQueueView = AccumulationQueueView;
-type index$f_AuthorizationPool = AuthorizationPool;
-type index$f_AuthorizationQueue = AuthorizationQueue;
-type index$f_AvailabilityAssignment = AvailabilityAssignment;
-declare const index$f_AvailabilityAssignment: typeof AvailabilityAssignment;
-type index$f_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
-declare const index$f_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
-type index$f_BlockState = BlockState;
-declare const index$f_BlockState: typeof BlockState;
-type index$f_BlocksState = BlocksState;
-type index$f_CoreStatistics = CoreStatistics;
-declare const index$f_CoreStatistics: typeof CoreStatistics;
-type index$f_DisputesRecords = DisputesRecords;
-declare const index$f_DisputesRecords: typeof DisputesRecords;
-declare const index$f_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
-declare const index$f_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
-type index$f_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
-type index$f_EnumerableState = EnumerableState;
-type index$f_FieldNames<T> = FieldNames<T>;
-type index$f_InMemoryService = InMemoryService;
-declare const index$f_InMemoryService: typeof InMemoryService;
-type index$f_InMemoryState = InMemoryState;
-declare const index$f_InMemoryState: typeof InMemoryState;
-type index$f_InMemoryStateFields = InMemoryStateFields;
-type index$f_LookupHistoryItem = LookupHistoryItem;
-declare const index$f_LookupHistoryItem: typeof LookupHistoryItem;
-type index$f_LookupHistorySlots = LookupHistorySlots;
-type index$f_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
-declare const index$f_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
-type index$f_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
-type index$f_NotYetAccumulatedReport = NotYetAccumulatedReport;
-declare const index$f_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
-type index$f_PerCore<T> = PerCore<T>;
-type index$f_PreimageItem = PreimageItem;
-declare const index$f_PreimageItem: typeof PreimageItem;
-type index$f_PrivilegedServices = PrivilegedServices;
-declare const index$f_PrivilegedServices: typeof PrivilegedServices;
-type index$f_RecentBlocks = RecentBlocks;
-declare const index$f_RecentBlocks: typeof RecentBlocks;
-type index$f_RecentBlocksView = RecentBlocksView;
-type index$f_RecentlyAccumulated = RecentlyAccumulated;
-type index$f_RecentlyAccumulatedView = RecentlyAccumulatedView;
-type index$f_SafroleData = SafroleData;
-declare const index$f_SafroleData: typeof SafroleData;
-type index$f_SafroleDataView = SafroleDataView;
-type index$f_SafroleSealingKeys = SafroleSealingKeys;
-type index$f_SafroleSealingKeysData = SafroleSealingKeysData;
-declare const index$f_SafroleSealingKeysData: typeof SafroleSealingKeysData;
-type index$f_SafroleSealingKeysKind = SafroleSealingKeysKind;
-declare const index$f_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
-type index$f_Service = Service;
-type index$f_ServiceAccountInfo = ServiceAccountInfo;
-declare const index$f_ServiceAccountInfo: typeof ServiceAccountInfo;
-type index$f_ServiceAccountInfoView = ServiceAccountInfoView;
-type index$f_ServiceData = ServiceData;
-type index$f_ServiceEntries = ServiceEntries;
-type index$f_ServiceStatistics = ServiceStatistics;
-declare const index$f_ServiceStatistics: typeof ServiceStatistics;
-type index$f_ServicesUpdate = ServicesUpdate;
-type index$f_State = State;
-type index$f_StateView = StateView;
-type index$f_StatisticsData = StatisticsData;
-declare const index$f_StatisticsData: typeof StatisticsData;
-type index$f_StatisticsDataView = StatisticsDataView;
-type index$f_StorageItem = StorageItem;
-declare const index$f_StorageItem: typeof StorageItem;
-type index$f_StorageKey = StorageKey;
-type index$f_UpdateError = UpdateError;
-declare const index$f_UpdateError: typeof UpdateError;
-type index$f_UpdatePreimage = UpdatePreimage;
-declare const index$f_UpdatePreimage: typeof UpdatePreimage;
-type index$f_UpdatePreimageKind = UpdatePreimageKind;
-declare const index$f_UpdatePreimageKind: typeof UpdatePreimageKind;
-type index$f_UpdateService = UpdateService;
-declare const index$f_UpdateService: typeof UpdateService;
-type index$f_UpdateServiceKind = UpdateServiceKind;
-declare const index$f_UpdateServiceKind: typeof UpdateServiceKind;
-type index$f_UpdateStorage = UpdateStorage;
-declare const index$f_UpdateStorage: typeof UpdateStorage;
-type index$f_UpdateStorageKind = UpdateStorageKind;
-declare const index$f_UpdateStorageKind: typeof UpdateStorageKind;
-type index$f_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
-type index$f_ValidatorData = ValidatorData;
-declare const index$f_ValidatorData: typeof ValidatorData;
-type index$f_ValidatorDataView = ValidatorDataView;
-type index$f_ValidatorStatistics = ValidatorStatistics;
-declare const index$f_ValidatorStatistics: typeof ValidatorStatistics;
-type index$f_WithStateView<V = StateView> = WithStateView<V>;
-declare const index$f_accumulationOutputComparator: typeof accumulationOutputComparator;
-declare const index$f_accumulationQueueCodec: typeof accumulationQueueCodec;
-declare const index$f_authPoolsCodec: typeof authPoolsCodec;
-declare const index$f_authQueuesCodec: typeof authQueuesCodec;
-declare const index$f_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
-declare const index$f_codecBandersnatchKey: typeof codecBandersnatchKey;
-declare const index$f_codecPerCore: typeof codecPerCore;
-declare const index$f_codecServiceId: typeof codecServiceId;
-declare const index$f_codecVarGas: typeof codecVarGas;
-declare const index$f_codecVarU16: typeof codecVarU16;
-declare const index$f_codecWithVersion: typeof codecWithVersion;
-declare const index$f_hashComparator: typeof hashComparator;
-declare const index$f_ignoreValueWithDefault: typeof ignoreValueWithDefault;
-declare const index$f_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
-declare const index$f_serviceDataCodec: typeof serviceDataCodec;
-declare const index$f_serviceEntriesCodec: typeof serviceEntriesCodec;
-declare const index$f_sortedSetCodec: typeof sortedSetCodec;
-declare const index$f_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
-declare const index$f_tryAsPerCore: typeof tryAsPerCore;
-declare const index$f_validatorsDataCodec: typeof validatorsDataCodec;
-declare const index$f_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
-declare const index$f_zeroSizeHint: typeof zeroSizeHint;
-declare namespace index$f {
-  export { index$f_AccumulationOutput as AccumulationOutput, index$f_AvailabilityAssignment as AvailabilityAssignment, index$f_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$f_BlockState as BlockState, index$f_CoreStatistics as CoreStatistics, index$f_DisputesRecords as DisputesRecords, index$f_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$f_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$f_InMemoryService as InMemoryService, index$f_InMemoryState as InMemoryState, index$f_LookupHistoryItem as LookupHistoryItem, index$f_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$f_NotYetAccumulatedReport as NotYetAccumulatedReport, index$f_PreimageItem as PreimageItem, index$f_PrivilegedServices as PrivilegedServices, index$f_RecentBlocks as RecentBlocks, index$f_SafroleData as SafroleData, index$f_SafroleSealingKeysData as SafroleSealingKeysData, index$f_SafroleSealingKeysKind as SafroleSealingKeysKind, index$f_ServiceAccountInfo as ServiceAccountInfo, index$f_ServiceStatistics as ServiceStatistics, index$f_StatisticsData as StatisticsData, index$f_StorageItem as StorageItem, index$f_UpdateError as UpdateError, index$f_UpdatePreimage as UpdatePreimage, index$f_UpdatePreimageKind as UpdatePreimageKind, index$f_UpdateService as UpdateService, index$f_UpdateServiceKind as UpdateServiceKind, index$f_UpdateStorage as UpdateStorage, index$f_UpdateStorageKind as UpdateStorageKind, index$f_ValidatorData as ValidatorData, index$f_ValidatorStatistics as ValidatorStatistics, index$f_accumulationOutputComparator as accumulationOutputComparator, index$f_accumulationQueueCodec as accumulationQueueCodec, index$f_authPoolsCodec as authPoolsCodec, index$f_authQueuesCodec as authQueuesCodec, index$f_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$f_codecBandersnatchKey as codecBandersnatchKey, index$f_codecPerCore as codecPerCore, index$f_codecServiceId as codecServiceId, index$f_codecVarGas as codecVarGas, index$f_codecVarU16 as codecVarU16, index$f_codecWithVersion as codecWithVersion, index$f_hashComparator as hashComparator, index$f_ignoreValueWithDefault as ignoreValueWithDefault, index$f_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$f_serviceDataCodec as serviceDataCodec, index$f_serviceEntriesCodec as serviceEntriesCodec, index$f_sortedSetCodec as sortedSetCodec, index$f_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$f_tryAsPerCore as tryAsPerCore, index$f_validatorsDataCodec as validatorsDataCodec, index$f_workReportsSortedSetCodec as workReportsSortedSetCodec, index$f_zeroSizeHint as zeroSizeHint };
-  export type { index$f_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$f_AccumulationQueue as AccumulationQueue, index$f_AccumulationQueueView as AccumulationQueueView, index$f_AuthorizationPool as AuthorizationPool, index$f_AuthorizationQueue as AuthorizationQueue, index$f_AvailabilityAssignmentsView as AvailabilityAssignmentsView, index$f_BlocksState as BlocksState, index$f_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$f_EnumerableState as EnumerableState, index$f_FieldNames as FieldNames, index$f_InMemoryStateFields as InMemoryStateFields, index$f_LookupHistorySlots as LookupHistorySlots, index$f_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$f_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$f_PerCore as PerCore, index$f_RecentBlocksView as RecentBlocksView, index$f_RecentlyAccumulated as RecentlyAccumulated, index$f_RecentlyAccumulatedView as RecentlyAccumulatedView, index$f_SafroleDataView as SafroleDataView, index$f_SafroleSealingKeys as SafroleSealingKeys, index$f_Service as Service, index$f_ServiceAccountInfoView as ServiceAccountInfoView, index$f_ServiceData as ServiceData, index$f_ServiceEntries as ServiceEntries, index$f_ServicesUpdate as ServicesUpdate, index$f_State as State, index$f_StateView as StateView, index$f_StatisticsDataView as StatisticsDataView, index$f_StorageKey as StorageKey, index$f_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$f_ValidatorDataView as ValidatorDataView, index$f_WithStateView as WithStateView };
+type index$e_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
+type index$e_AccumulationOutput = AccumulationOutput;
+declare const index$e_AccumulationOutput: typeof AccumulationOutput;
+type index$e_AccumulationQueue = AccumulationQueue;
+type index$e_AccumulationQueueView = AccumulationQueueView;
+type index$e_AuthorizationPool = AuthorizationPool;
+type index$e_AuthorizationQueue = AuthorizationQueue;
+type index$e_AvailabilityAssignment = AvailabilityAssignment;
+declare const index$e_AvailabilityAssignment: typeof AvailabilityAssignment;
+type index$e_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
+declare const index$e_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
+type index$e_BlockState = BlockState;
+declare const index$e_BlockState: typeof BlockState;
+type index$e_BlocksState = BlocksState;
+type index$e_CoreStatistics = CoreStatistics;
+declare const index$e_CoreStatistics: typeof CoreStatistics;
+type index$e_DisputesRecords = DisputesRecords;
+declare const index$e_DisputesRecords: typeof DisputesRecords;
+declare const index$e_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
+declare const index$e_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
+type index$e_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
+type index$e_EnumerableState = EnumerableState;
+type index$e_FieldNames<T> = FieldNames<T>;
+type index$e_InMemoryService = InMemoryService;
+declare const index$e_InMemoryService: typeof InMemoryService;
+type index$e_InMemoryState = InMemoryState;
+declare const index$e_InMemoryState: typeof InMemoryState;
+type index$e_InMemoryStateFields = InMemoryStateFields;
+type index$e_LookupHistoryItem = LookupHistoryItem;
+declare const index$e_LookupHistoryItem: typeof LookupHistoryItem;
+type index$e_LookupHistorySlots = LookupHistorySlots;
+type index$e_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
+declare const index$e_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
+type index$e_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
+type index$e_NotYetAccumulatedReport = NotYetAccumulatedReport;
+declare const index$e_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
+type index$e_PerCore<T> = PerCore<T>;
+type index$e_PreimageItem = PreimageItem;
+declare const index$e_PreimageItem: typeof PreimageItem;
+type index$e_PrivilegedServices = PrivilegedServices;
+declare const index$e_PrivilegedServices: typeof PrivilegedServices;
+type index$e_RecentBlocks = RecentBlocks;
+declare const index$e_RecentBlocks: typeof RecentBlocks;
+type index$e_RecentBlocksView = RecentBlocksView;
+type index$e_RecentlyAccumulated = RecentlyAccumulated;
+type index$e_RecentlyAccumulatedView = RecentlyAccumulatedView;
+type index$e_SafroleData = SafroleData;
+declare const index$e_SafroleData: typeof SafroleData;
+type index$e_SafroleDataView = SafroleDataView;
+type index$e_SafroleSealingKeys = SafroleSealingKeys;
+type index$e_SafroleSealingKeysData = SafroleSealingKeysData;
+declare const index$e_SafroleSealingKeysData: typeof SafroleSealingKeysData;
+type index$e_SafroleSealingKeysKind = SafroleSealingKeysKind;
+declare const index$e_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
+type index$e_Service = Service;
+type index$e_ServiceAccountInfo = ServiceAccountInfo;
+declare const index$e_ServiceAccountInfo: typeof ServiceAccountInfo;
+type index$e_ServiceAccountInfoView = ServiceAccountInfoView;
+type index$e_ServiceData = ServiceData;
+type index$e_ServiceEntries = ServiceEntries;
+type index$e_ServiceStatistics = ServiceStatistics;
+declare const index$e_ServiceStatistics: typeof ServiceStatistics;
+type index$e_ServicesUpdate = ServicesUpdate;
+type index$e_State = State;
+type index$e_StateView = StateView;
+type index$e_StatisticsData = StatisticsData;
+declare const index$e_StatisticsData: typeof StatisticsData;
+type index$e_StatisticsDataView = StatisticsDataView;
+type index$e_StorageItem = StorageItem;
+declare const index$e_StorageItem: typeof StorageItem;
+type index$e_StorageKey = StorageKey;
+type index$e_UpdateError = UpdateError;
+declare const index$e_UpdateError: typeof UpdateError;
+type index$e_UpdatePreimage = UpdatePreimage;
+declare const index$e_UpdatePreimage: typeof UpdatePreimage;
+type index$e_UpdatePreimageKind = UpdatePreimageKind;
+declare const index$e_UpdatePreimageKind: typeof UpdatePreimageKind;
+type index$e_UpdateService = UpdateService;
+declare const index$e_UpdateService: typeof UpdateService;
+type index$e_UpdateServiceKind = UpdateServiceKind;
+declare const index$e_UpdateServiceKind: typeof UpdateServiceKind;
+type index$e_UpdateStorage = UpdateStorage;
+declare const index$e_UpdateStorage: typeof UpdateStorage;
+type index$e_UpdateStorageKind = UpdateStorageKind;
+declare const index$e_UpdateStorageKind: typeof UpdateStorageKind;
+type index$e_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
+type index$e_ValidatorData = ValidatorData;
+declare const index$e_ValidatorData: typeof ValidatorData;
+type index$e_ValidatorDataView = ValidatorDataView;
+type index$e_ValidatorStatistics = ValidatorStatistics;
+declare const index$e_ValidatorStatistics: typeof ValidatorStatistics;
+type index$e_WithStateView<V = StateView> = WithStateView<V>;
+declare const index$e_accumulationOutputComparator: typeof accumulationOutputComparator;
+declare const index$e_accumulationQueueCodec: typeof accumulationQueueCodec;
+declare const index$e_authPoolsCodec: typeof authPoolsCodec;
+declare const index$e_authQueuesCodec: typeof authQueuesCodec;
+declare const index$e_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
+declare const index$e_codecBandersnatchKey: typeof codecBandersnatchKey;
+declare const index$e_codecPerCore: typeof codecPerCore;
+declare const index$e_codecServiceId: typeof codecServiceId;
+declare const index$e_codecVarGas: typeof codecVarGas;
+declare const index$e_codecVarU16: typeof codecVarU16;
+declare const index$e_codecWithVersion: typeof codecWithVersion;
+declare const index$e_hashComparator: typeof hashComparator;
+declare const index$e_ignoreValueWithDefault: typeof ignoreValueWithDefault;
+declare const index$e_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
+declare const index$e_serviceDataCodec: typeof serviceDataCodec;
+declare const index$e_serviceEntriesCodec: typeof serviceEntriesCodec;
+declare const index$e_sortedSetCodec: typeof sortedSetCodec;
+declare const index$e_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
+declare const index$e_tryAsPerCore: typeof tryAsPerCore;
+declare const index$e_validatorsDataCodec: typeof validatorsDataCodec;
+declare const index$e_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
+declare const index$e_zeroSizeHint: typeof zeroSizeHint;
+declare namespace index$e {
+  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_NotYetAccumulatedReport as NotYetAccumulatedReport, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_accumulationQueueCodec as accumulationQueueCodec, index$e_authPoolsCodec as authPoolsCodec, index$e_authQueuesCodec as authQueuesCodec, index$e_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithVersion as codecWithVersion, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_validatorsDataCodec as validatorsDataCodec, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export type { index$e_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$e_AccumulationQueue as AccumulationQueue, index$e_AccumulationQueueView as AccumulationQueueView, index$e_AuthorizationPool as AuthorizationPool, index$e_AuthorizationQueue as AuthorizationQueue, index$e_AvailabilityAssignmentsView as AvailabilityAssignmentsView, index$e_BlocksState as BlocksState, index$e_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$e_EnumerableState as EnumerableState, index$e_FieldNames as FieldNames, index$e_InMemoryStateFields as InMemoryStateFields, index$e_LookupHistorySlots as LookupHistorySlots, index$e_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_RecentBlocksView as RecentBlocksView, index$e_RecentlyAccumulated as RecentlyAccumulated, index$e_RecentlyAccumulatedView as RecentlyAccumulatedView, index$e_SafroleDataView as SafroleDataView, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceAccountInfoView as ServiceAccountInfoView, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StateView as StateView, index$e_StatisticsDataView as StatisticsDataView, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$e_ValidatorDataView as ValidatorDataView, index$e_WithStateView as WithStateView };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -12775,47 +13315,47 @@ declare function loadState(spec: ChainSpec, blake2b: Blake2b, entries: Iterable<
  *        hashmap of `key -> value` entries.
  */
 
-declare const index$e_EMPTY_BLOB: typeof EMPTY_BLOB;
-type index$e_EncodeFun = EncodeFun;
-type index$e_KeyAndCodec<T> = KeyAndCodec<T>;
-type index$e_KeyAndCodecWithView<T, V> = KeyAndCodecWithView<T, V>;
-type index$e_SerializedService = SerializedService;
-declare const index$e_SerializedService: typeof SerializedService;
-type index$e_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
-declare const index$e_SerializedState: typeof SerializedState;
-type index$e_SerializedStateBackend = SerializedStateBackend;
-type index$e_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
-declare const index$e_SerializedStateView: typeof SerializedStateView;
-type index$e_StateCodec<T, V = T> = StateCodec<T, V>;
-type index$e_StateEntries = StateEntries;
-declare const index$e_StateEntries: typeof StateEntries;
-type index$e_StateEntryUpdate = StateEntryUpdate;
-type index$e_StateEntryUpdateAction = StateEntryUpdateAction;
-declare const index$e_StateEntryUpdateAction: typeof StateEntryUpdateAction;
-type index$e_StateKey = StateKey;
-type index$e_StateKeyIdx = StateKeyIdx;
-declare const index$e_StateKeyIdx: typeof StateKeyIdx;
-declare const index$e_TYPICAL_STATE_ITEMS: typeof TYPICAL_STATE_ITEMS;
-declare const index$e_TYPICAL_STATE_ITEM_LEN: typeof TYPICAL_STATE_ITEM_LEN;
-declare const index$e_U32_BYTES: typeof U32_BYTES;
-declare const index$e_binaryMerkleization: typeof binaryMerkleization;
-declare const index$e_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
-declare const index$e_dumpCodec: typeof dumpCodec;
-declare const index$e_getSafroleData: typeof getSafroleData;
-declare const index$e_legacyServiceNested: typeof legacyServiceNested;
-declare const index$e_loadState: typeof loadState;
-import index$e_serialize = serialize;
-declare const index$e_serializeBasicKeys: typeof serializeBasicKeys;
-declare const index$e_serializePreimages: typeof serializePreimages;
-declare const index$e_serializeRemovedServices: typeof serializeRemovedServices;
-declare const index$e_serializeServiceUpdates: typeof serializeServiceUpdates;
-declare const index$e_serializeStateUpdate: typeof serializeStateUpdate;
-declare const index$e_serializeStorage: typeof serializeStorage;
-declare const index$e_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
-import index$e_stateKeys = stateKeys;
-declare namespace index$e {
-  export { index$e_EMPTY_BLOB as EMPTY_BLOB, index$e_SerializedService as SerializedService, index$e_SerializedState as SerializedState, index$e_SerializedStateView as SerializedStateView, index$e_StateEntries as StateEntries, index$e_StateEntryUpdateAction as StateEntryUpdateAction, index$e_StateKeyIdx as StateKeyIdx, index$e_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$e_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$e_U32_BYTES as U32_BYTES, index$e_binaryMerkleization as binaryMerkleization, index$e_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$e_dumpCodec as dumpCodec, index$e_getSafroleData as getSafroleData, index$e_legacyServiceNested as legacyServiceNested, index$e_loadState as loadState, index$e_serialize as serialize, index$e_serializeBasicKeys as serializeBasicKeys, index$e_serializePreimages as serializePreimages, index$e_serializeRemovedServices as serializeRemovedServices, index$e_serializeServiceUpdates as serializeServiceUpdates, index$e_serializeStateUpdate as serializeStateUpdate, index$e_serializeStorage as serializeStorage, index$e_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$e_stateKeys as stateKeys };
-  export type { index$e_EncodeFun as EncodeFun, index$e_KeyAndCodec as KeyAndCodec, index$e_KeyAndCodecWithView as KeyAndCodecWithView, index$e_SerializedStateBackend as SerializedStateBackend, index$e_StateCodec as StateCodec, index$e_StateEntryUpdate as StateEntryUpdate, index$e_StateKey as StateKey };
+declare const index$d_EMPTY_BLOB: typeof EMPTY_BLOB;
+type index$d_EncodeFun = EncodeFun;
+type index$d_KeyAndCodec<T> = KeyAndCodec<T>;
+type index$d_KeyAndCodecWithView<T, V> = KeyAndCodecWithView<T, V>;
+type index$d_SerializedService = SerializedService;
+declare const index$d_SerializedService: typeof SerializedService;
+type index$d_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
+declare const index$d_SerializedState: typeof SerializedState;
+type index$d_SerializedStateBackend = SerializedStateBackend;
+type index$d_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
+declare const index$d_SerializedStateView: typeof SerializedStateView;
+type index$d_StateCodec<T, V = T> = StateCodec<T, V>;
+type index$d_StateEntries = StateEntries;
+declare const index$d_StateEntries: typeof StateEntries;
+type index$d_StateEntryUpdate = StateEntryUpdate;
+type index$d_StateEntryUpdateAction = StateEntryUpdateAction;
+declare const index$d_StateEntryUpdateAction: typeof StateEntryUpdateAction;
+type index$d_StateKey = StateKey;
+type index$d_StateKeyIdx = StateKeyIdx;
+declare const index$d_StateKeyIdx: typeof StateKeyIdx;
+declare const index$d_TYPICAL_STATE_ITEMS: typeof TYPICAL_STATE_ITEMS;
+declare const index$d_TYPICAL_STATE_ITEM_LEN: typeof TYPICAL_STATE_ITEM_LEN;
+declare const index$d_U32_BYTES: typeof U32_BYTES;
+declare const index$d_binaryMerkleization: typeof binaryMerkleization;
+declare const index$d_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
+declare const index$d_dumpCodec: typeof dumpCodec;
+declare const index$d_getSafroleData: typeof getSafroleData;
+declare const index$d_legacyServiceNested: typeof legacyServiceNested;
+declare const index$d_loadState: typeof loadState;
+import index$d_serialize = serialize;
+declare const index$d_serializeBasicKeys: typeof serializeBasicKeys;
+declare const index$d_serializePreimages: typeof serializePreimages;
+declare const index$d_serializeRemovedServices: typeof serializeRemovedServices;
+declare const index$d_serializeServiceUpdates: typeof serializeServiceUpdates;
+declare const index$d_serializeStateUpdate: typeof serializeStateUpdate;
+declare const index$d_serializeStorage: typeof serializeStorage;
+declare const index$d_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
+import index$d_stateKeys = stateKeys;
+declare namespace index$d {
+  export { index$d_EMPTY_BLOB as EMPTY_BLOB, index$d_SerializedService as SerializedService, index$d_SerializedState as SerializedState, index$d_SerializedStateView as SerializedStateView, index$d_StateEntries as StateEntries, index$d_StateEntryUpdateAction as StateEntryUpdateAction, index$d_StateKeyIdx as StateKeyIdx, index$d_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$d_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$d_U32_BYTES as U32_BYTES, index$d_binaryMerkleization as binaryMerkleization, index$d_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$d_dumpCodec as dumpCodec, index$d_getSafroleData as getSafroleData, index$d_legacyServiceNested as legacyServiceNested, index$d_loadState as loadState, index$d_serialize as serialize, index$d_serializeBasicKeys as serializeBasicKeys, index$d_serializePreimages as serializePreimages, index$d_serializeRemovedServices as serializeRemovedServices, index$d_serializeServiceUpdates as serializeServiceUpdates, index$d_serializeStateUpdate as serializeStateUpdate, index$d_serializeStorage as serializeStorage, index$d_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$d_stateKeys as stateKeys };
+  export type { index$d_EncodeFun as EncodeFun, index$d_KeyAndCodec as KeyAndCodec, index$d_KeyAndCodecWithView as KeyAndCodecWithView, index$d_SerializedStateBackend as SerializedStateBackend, index$d_StateCodec as StateCodec, index$d_StateEntryUpdate as StateEntryUpdate, index$d_StateKey as StateKey };
 }
 
 /** Error during `LeafDb` creation. */
@@ -13171,31 +13711,31 @@ declare class InMemorySerializedStates implements StatesDb<SerializedState<LeafD
   async close() {}
 }
 
-type index$d_BlocksDb = BlocksDb;
-type index$d_InMemoryBlocks = InMemoryBlocks;
-declare const index$d_InMemoryBlocks: typeof InMemoryBlocks;
-type index$d_InMemorySerializedStates = InMemorySerializedStates;
-declare const index$d_InMemorySerializedStates: typeof InMemorySerializedStates;
-type index$d_InMemoryStates = InMemoryStates;
-declare const index$d_InMemoryStates: typeof InMemoryStates;
-type index$d_InitStatesDb<T = State> = InitStatesDb<T>;
-type index$d_LeafDb = LeafDb;
-declare const index$d_LeafDb: typeof LeafDb;
-type index$d_LeafDbError = LeafDbError;
-declare const index$d_LeafDbError: typeof LeafDbError;
-type index$d_Lookup = Lookup;
-type index$d_LookupKind = LookupKind;
-declare const index$d_LookupKind: typeof LookupKind;
-type index$d_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
-type index$d_SerializedStatesDb = SerializedStatesDb;
-type index$d_StateUpdateError = StateUpdateError;
-declare const index$d_StateUpdateError: typeof StateUpdateError;
-type index$d_StatesDb<T extends State = State> = StatesDb<T>;
-type index$d_ValuesDb = ValuesDb;
-declare const index$d_updateLeafs: typeof updateLeafs;
-declare namespace index$d {
-  export { index$d_InMemoryBlocks as InMemoryBlocks, index$d_InMemorySerializedStates as InMemorySerializedStates, index$d_InMemoryStates as InMemoryStates, index$d_LeafDb as LeafDb, index$d_LeafDbError as LeafDbError, index$d_LookupKind as LookupKind, index$d_StateUpdateError as StateUpdateError, index$d_updateLeafs as updateLeafs };
-  export type { index$d_BlocksDb as BlocksDb, index$d_InitStatesDb as InitStatesDb, index$d_Lookup as Lookup, index$d_RootDb as RootDb, index$d_SerializedStatesDb as SerializedStatesDb, index$d_StatesDb as StatesDb, index$d_ValuesDb as ValuesDb };
+type index$c_BlocksDb = BlocksDb;
+type index$c_InMemoryBlocks = InMemoryBlocks;
+declare const index$c_InMemoryBlocks: typeof InMemoryBlocks;
+type index$c_InMemorySerializedStates = InMemorySerializedStates;
+declare const index$c_InMemorySerializedStates: typeof InMemorySerializedStates;
+type index$c_InMemoryStates = InMemoryStates;
+declare const index$c_InMemoryStates: typeof InMemoryStates;
+type index$c_InitStatesDb<T = State> = InitStatesDb<T>;
+type index$c_LeafDb = LeafDb;
+declare const index$c_LeafDb: typeof LeafDb;
+type index$c_LeafDbError = LeafDbError;
+declare const index$c_LeafDbError: typeof LeafDbError;
+type index$c_Lookup = Lookup;
+type index$c_LookupKind = LookupKind;
+declare const index$c_LookupKind: typeof LookupKind;
+type index$c_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
+type index$c_SerializedStatesDb = SerializedStatesDb;
+type index$c_StateUpdateError = StateUpdateError;
+declare const index$c_StateUpdateError: typeof StateUpdateError;
+type index$c_StatesDb<T extends State = State> = StatesDb<T>;
+type index$c_ValuesDb = ValuesDb;
+declare const index$c_updateLeafs: typeof updateLeafs;
+declare namespace index$c {
+  export { index$c_InMemoryBlocks as InMemoryBlocks, index$c_InMemorySerializedStates as InMemorySerializedStates, index$c_InMemoryStates as InMemoryStates, index$c_LeafDb as LeafDb, index$c_LeafDbError as LeafDbError, index$c_LookupKind as LookupKind, index$c_StateUpdateError as StateUpdateError, index$c_updateLeafs as updateLeafs };
+  export type { index$c_BlocksDb as BlocksDb, index$c_InitStatesDb as InitStatesDb, index$c_Lookup as Lookup, index$c_RootDb as RootDb, index$c_SerializedStatesDb as SerializedStatesDb, index$c_StatesDb as StatesDb, index$c_ValuesDb as ValuesDb };
 }
 
 /**
@@ -13617,31 +14157,31 @@ declare const initEc = async () => {
   await init.reedSolomon();
 };
 
-declare const index$c_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
-declare const index$c_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
-type index$c_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
-type index$c_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
-type index$c_PIECE_SIZE = PIECE_SIZE;
-declare const index$c_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
-type index$c_POINT_LENGTH = POINT_LENGTH;
-declare const index$c_checkConsistency: typeof checkConsistency;
-declare const index$c_chunkingFunction: typeof chunkingFunction;
-declare const index$c_chunksToShards: typeof chunksToShards;
-declare const index$c_decodeData: typeof decodeData;
-declare const index$c_decodeDataAndTrim: typeof decodeDataAndTrim;
-declare const index$c_decodePiece: typeof decodePiece;
-declare const index$c_encodePoints: typeof encodePoints;
-declare const index$c_initEc: typeof initEc;
-declare const index$c_join: typeof join;
-declare const index$c_lace: typeof lace;
-declare const index$c_padAndEncodeData: typeof padAndEncodeData;
-declare const index$c_shardsToChunks: typeof shardsToChunks;
-declare const index$c_split: typeof split;
-declare const index$c_transpose: typeof transpose;
-declare const index$c_unzip: typeof unzip;
-declare namespace index$c {
-  export { index$c_HALF_POINT_SIZE as HALF_POINT_SIZE, index$c_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$c_POINT_ALIGNMENT as POINT_ALIGNMENT, index$c_checkConsistency as checkConsistency, index$c_chunkingFunction as chunkingFunction, index$c_chunksToShards as chunksToShards, index$c_decodeData as decodeData, index$c_decodeDataAndTrim as decodeDataAndTrim, index$c_decodePiece as decodePiece, index$c_encodePoints as encodePoints, index$c_initEc as initEc, index$c_join as join, index$c_lace as lace, index$c_padAndEncodeData as padAndEncodeData, index$c_shardsToChunks as shardsToChunks, index$c_split as split, index$c_transpose as transpose, index$c_unzip as unzip };
-  export type { index$c_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$c_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$c_PIECE_SIZE as PIECE_SIZE, index$c_POINT_LENGTH as POINT_LENGTH };
+declare const index$b_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
+declare const index$b_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
+type index$b_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
+type index$b_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
+type index$b_PIECE_SIZE = PIECE_SIZE;
+declare const index$b_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
+type index$b_POINT_LENGTH = POINT_LENGTH;
+declare const index$b_checkConsistency: typeof checkConsistency;
+declare const index$b_chunkingFunction: typeof chunkingFunction;
+declare const index$b_chunksToShards: typeof chunksToShards;
+declare const index$b_decodeData: typeof decodeData;
+declare const index$b_decodeDataAndTrim: typeof decodeDataAndTrim;
+declare const index$b_decodePiece: typeof decodePiece;
+declare const index$b_encodePoints: typeof encodePoints;
+declare const index$b_initEc: typeof initEc;
+declare const index$b_join: typeof join;
+declare const index$b_lace: typeof lace;
+declare const index$b_padAndEncodeData: typeof padAndEncodeData;
+declare const index$b_shardsToChunks: typeof shardsToChunks;
+declare const index$b_split: typeof split;
+declare const index$b_transpose: typeof transpose;
+declare const index$b_unzip: typeof unzip;
+declare namespace index$b {
+  export { index$b_HALF_POINT_SIZE as HALF_POINT_SIZE, index$b_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$b_POINT_ALIGNMENT as POINT_ALIGNMENT, index$b_checkConsistency as checkConsistency, index$b_chunkingFunction as chunkingFunction, index$b_chunksToShards as chunksToShards, index$b_decodeData as decodeData, index$b_decodeDataAndTrim as decodeDataAndTrim, index$b_decodePiece as decodePiece, index$b_encodePoints as encodePoints, index$b_initEc as initEc, index$b_join as join, index$b_lace as lace, index$b_padAndEncodeData as padAndEncodeData, index$b_shardsToChunks as shardsToChunks, index$b_split as split, index$b_transpose as transpose, index$b_unzip as unzip };
+  export type { index$b_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$b_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$b_PIECE_SIZE as PIECE_SIZE, index$b_POINT_LENGTH as POINT_LENGTH };
 }
 
 /** A per-client handler of incoming socket messages. */
@@ -14144,45 +14684,45 @@ declare class FuzzTarget implements IpcHandler {
   }
 }
 
-type index$b_Ancestry = Ancestry;
-type index$b_AncestryItem = AncestryItem;
-declare const index$b_AncestryItem: typeof AncestryItem;
-type index$b_ErrorMessage = ErrorMessage;
-declare const index$b_ErrorMessage: typeof ErrorMessage;
-type index$b_Features = Features;
-declare const index$b_Features: typeof Features;
-type index$b_FuzzMessageHandler = FuzzMessageHandler;
-type index$b_FuzzTarget = FuzzTarget;
-declare const index$b_FuzzTarget: typeof FuzzTarget;
-type index$b_GetState = GetState;
-type index$b_Initialize = Initialize;
-declare const index$b_Initialize: typeof Initialize;
-type index$b_KeyValue = KeyValue;
-declare const index$b_KeyValue: typeof KeyValue;
-type index$b_Message = Message;
-type index$b_MessageData = MessageData;
-type index$b_MessageType = MessageType;
-declare const index$b_MessageType: typeof MessageType;
-type index$b_PeerInfo = PeerInfo;
-declare const index$b_PeerInfo: typeof PeerInfo;
-type index$b_StateRoot = StateRoot;
-type index$b_Version = Version;
-declare const index$b_Version: typeof Version;
-declare const index$b_ancestryCodec: typeof ancestryCodec;
-declare const index$b_getStateCodec: typeof getStateCodec;
-declare const index$b_messageCodec: typeof messageCodec;
-declare const index$b_stateCodec: typeof stateCodec;
-declare const index$b_stateRootCodec: typeof stateRootCodec;
-declare namespace index$b {
-  export { index$b_AncestryItem as AncestryItem, index$b_ErrorMessage as ErrorMessage, index$b_Features as Features, index$b_FuzzTarget as FuzzTarget, index$b_Initialize as Initialize, index$b_KeyValue as KeyValue, index$b_MessageType as MessageType, index$b_PeerInfo as PeerInfo, index$b_Version as Version, index$b_ancestryCodec as ancestryCodec, index$b_getStateCodec as getStateCodec, logger$1 as logger, index$b_messageCodec as messageCodec, index$b_stateCodec as stateCodec, index$b_stateRootCodec as stateRootCodec };
-  export type { index$b_Ancestry as Ancestry, index$b_FuzzMessageHandler as FuzzMessageHandler, index$b_GetState as GetState, index$b_Message as Message, index$b_MessageData as MessageData, index$b_StateRoot as StateRoot };
+type index$a_Ancestry = Ancestry;
+type index$a_AncestryItem = AncestryItem;
+declare const index$a_AncestryItem: typeof AncestryItem;
+type index$a_ErrorMessage = ErrorMessage;
+declare const index$a_ErrorMessage: typeof ErrorMessage;
+type index$a_Features = Features;
+declare const index$a_Features: typeof Features;
+type index$a_FuzzMessageHandler = FuzzMessageHandler;
+type index$a_FuzzTarget = FuzzTarget;
+declare const index$a_FuzzTarget: typeof FuzzTarget;
+type index$a_GetState = GetState;
+type index$a_Initialize = Initialize;
+declare const index$a_Initialize: typeof Initialize;
+type index$a_KeyValue = KeyValue;
+declare const index$a_KeyValue: typeof KeyValue;
+type index$a_Message = Message;
+type index$a_MessageData = MessageData;
+type index$a_MessageType = MessageType;
+declare const index$a_MessageType: typeof MessageType;
+type index$a_PeerInfo = PeerInfo;
+declare const index$a_PeerInfo: typeof PeerInfo;
+type index$a_StateRoot = StateRoot;
+type index$a_Version = Version;
+declare const index$a_Version: typeof Version;
+declare const index$a_ancestryCodec: typeof ancestryCodec;
+declare const index$a_getStateCodec: typeof getStateCodec;
+declare const index$a_messageCodec: typeof messageCodec;
+declare const index$a_stateCodec: typeof stateCodec;
+declare const index$a_stateRootCodec: typeof stateRootCodec;
+declare namespace index$a {
+  export { index$a_AncestryItem as AncestryItem, index$a_ErrorMessage as ErrorMessage, index$a_Features as Features, index$a_FuzzTarget as FuzzTarget, index$a_Initialize as Initialize, index$a_KeyValue as KeyValue, index$a_MessageType as MessageType, index$a_PeerInfo as PeerInfo, index$a_Version as Version, index$a_ancestryCodec as ancestryCodec, index$a_getStateCodec as getStateCodec, logger$1 as logger, index$a_messageCodec as messageCodec, index$a_stateCodec as stateCodec, index$a_stateRootCodec as stateRootCodec };
+  export type { index$a_Ancestry as Ancestry, index$a_FuzzMessageHandler as FuzzMessageHandler, index$a_GetState as GetState, index$a_Message as Message, index$a_MessageData as MessageData, index$a_StateRoot as StateRoot };
 }
 
-type index$a_IpcHandler = IpcHandler;
-type index$a_IpcSender = IpcSender;
-declare namespace index$a {
-  export { index$b as v1 };
-  export type { index$a_IpcHandler as IpcHandler, index$a_IpcSender as IpcSender };
+type index$9_IpcHandler = IpcHandler;
+type index$9_IpcSender = IpcSender;
+declare namespace index$9 {
+  export { index$a as v1 };
+  export type { index$9_IpcHandler as IpcHandler, index$9_IpcSender as IpcSender };
 }
 
 /** Size of the transfer memo. */
@@ -14547,8 +15087,6 @@ interface IMemory {
   read(address: U32, result: Uint8Array): Result$2<OK, PageFault$1>;
 }
 
-declare const NO_OF_REGISTERS$1 = 13;
-
 /** Allow to set and get all registers encoded into little-endian bytes. */
 interface IRegisters {
   /**
@@ -14848,11 +15386,6 @@ declare class HostCallsManager {
   }
 }
 
-/** Create a new gas counter instance depending on the gas value. */
-declare function gasCounter(gas: Gas): IGasCounter {
-  return new GasCounterU64(tryAsU64(gas));
-}
-
 type MemoryIndex = Opaque<number, "memory index">;
 
 declare const tryAsMemoryIndex = (index: number): MemoryIndex => {
@@ -15467,25 +16000,25 @@ declare function getRegisters(argsLength: number) {
   return regs;
 }
 
-type index$9_MemorySegment = MemorySegment;
-declare const index$9_MemorySegment: typeof MemorySegment;
-declare const index$9_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
-type index$9_SpiMemory = SpiMemory;
-declare const index$9_SpiMemory: typeof SpiMemory;
-type index$9_SpiProgram = SpiProgram;
-declare const index$9_SpiProgram: typeof SpiProgram;
-declare const index$9_decodeStandardProgram: typeof decodeStandardProgram;
-declare const index$9_getMemorySegment: typeof getMemorySegment;
-declare const index$9_getRegisters: typeof getRegisters;
-declare namespace index$9 {
+type index$8_MemorySegment = MemorySegment;
+declare const index$8_MemorySegment: typeof MemorySegment;
+declare const index$8_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
+type index$8_SpiMemory = SpiMemory;
+declare const index$8_SpiMemory: typeof SpiMemory;
+type index$8_SpiProgram = SpiProgram;
+declare const index$8_SpiProgram: typeof SpiProgram;
+declare const index$8_decodeStandardProgram: typeof decodeStandardProgram;
+declare const index$8_getMemorySegment: typeof getMemorySegment;
+declare const index$8_getRegisters: typeof getRegisters;
+declare namespace index$8 {
   export {
-    index$9_MemorySegment as MemorySegment,
-    index$9_NO_OF_REGISTERS as NO_OF_REGISTERS,
-    index$9_SpiMemory as SpiMemory,
-    index$9_SpiProgram as SpiProgram,
-    index$9_decodeStandardProgram as decodeStandardProgram,
-    index$9_getMemorySegment as getMemorySegment,
-    index$9_getRegisters as getRegisters,
+    index$8_MemorySegment as MemorySegment,
+    index$8_NO_OF_REGISTERS as NO_OF_REGISTERS,
+    index$8_SpiMemory as SpiMemory,
+    index$8_SpiProgram as SpiProgram,
+    index$8_decodeStandardProgram as decodeStandardProgram,
+    index$8_getMemorySegment as getMemorySegment,
+    index$8_getRegisters as getRegisters,
   };
 }
 
@@ -15543,13 +16076,13 @@ declare function extractCodeAndMetadata(blobWithMetadata: Uint8Array) {
   return { metadata, code };
 }
 
-type index$8_Program = Program;
-declare const index$8_Program: typeof Program;
-declare const index$8_extractCodeAndMetadata: typeof extractCodeAndMetadata;
-declare namespace index$8 {
+type index$7_Program = Program;
+declare const index$7_Program: typeof Program;
+declare const index$7_extractCodeAndMetadata: typeof extractCodeAndMetadata;
+declare namespace index$7 {
   export {
-    index$8_Program as Program,
-    index$8_extractCodeAndMetadata as extractCodeAndMetadata,
+    index$7_Program as Program,
+    index$7_extractCodeAndMetadata as extractCodeAndMetadata,
   };
 }
 
@@ -15722,38 +16255,6 @@ declare class ImmediateDecoder {
   }
 }
 
-declare class NibblesDecoder {
-  private byte = new Int8Array(1);
-
-  setByte(byte: number) {
-    this.byte[0] = byte;
-  }
-
-  getHighNibble() {
-    return (this.byte[0] & 0xf0) >>> 4;
-  }
-
-  getLowNibble() {
-    return this.byte[0] & 0x0f;
-  }
-
-  getHighNibbleAsRegisterIndex() {
-    return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
-  }
-
-  getLowNibbleAsRegisterIndex() {
-    return Math.min(this.getLowNibble(), MAX_REGISTER_INDEX);
-  }
-
-  getHighNibbleAsLength() {
-    return Math.min(this.getHighNibble(), MAX_LENGTH);
-  }
-
-  getLowNibbleAsLength() {
-    return Math.min(this.getLowNibble(), MAX_LENGTH);
-  }
-}
-
 type EmptyArgs = {
   type: ArgumentType.NO_ARGUMENTS;
   noOfBytesToSkip: number;
@@ -16092,106 +16593,6 @@ declare class ArgsDecoder {
   }
 }
 
-declare const createResults = () => {
-  const results = new Array(ARGUMENT_TYPE_LENGTH) as Results;
-
-  results[ArgumentType.NO_ARGUMENTS] = {
-    type: ArgumentType.NO_ARGUMENTS,
-    noOfBytesToSkip: 1,
-  };
-
-  results[ArgumentType.ONE_IMMEDIATE] = {
-    type: ArgumentType.ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    immediateDecoder: new ImmediateDecoder(),
-  };
-
-  results[ArgumentType.TWO_REGISTERS] = {
-    type: ArgumentType.TWO_REGISTERS,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-  };
-
-  results[ArgumentType.THREE_REGISTERS] = {
-    type: ArgumentType.THREE_REGISTERS,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    thirdRegisterIndex: 0,
-  };
-
-  results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET] = {
-    type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-    nextPc: 0,
-  };
-
-  results[ArgumentType.TWO_REGISTERS_ONE_OFFSET] = {
-    type: ArgumentType.TWO_REGISTERS_ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    nextPc: 0,
-  };
-
-  results[ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE] = {
-    type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-  };
-
-  results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE] = {
-    type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-  };
-
-  results[ArgumentType.ONE_REGISTER_TWO_IMMEDIATES] = {
-    type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-  };
-
-  results[ArgumentType.ONE_OFFSET] = {
-    type: ArgumentType.ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    nextPc: 0,
-  };
-
-  results[ArgumentType.TWO_IMMEDIATES] = {
-    type: ArgumentType.TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-  };
-
-  results[ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES] = {
-    type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-  };
-
-  results[ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE] = {
-    type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE,
-    noOfBytesToSkip: 9,
-    registerIndex: 0,
-    immediateDecoder: new ExtendedWitdthImmediateDecoder(),
-  };
-
-  return results;
-};
-
 declare enum Instruction {
   TRAP = 0,
   FALLTHROUGH = 1,
@@ -16334,164 +16735,6 @@ declare enum Instruction {
   MIN_U = 230,
 }
 
-declare const instructionArgumentTypeMap = (() => {
-  const instructionArgumentTypeMap = new Array<ArgumentType>(HIGHEST_INSTRUCTION_NUMBER + 1);
-
-  instructionArgumentTypeMap[Instruction.TRAP] = ArgumentType.NO_ARGUMENTS;
-  instructionArgumentTypeMap[Instruction.FALLTHROUGH] = ArgumentType.NO_ARGUMENTS;
-
-  instructionArgumentTypeMap[Instruction.ECALLI] = ArgumentType.ONE_IMMEDIATE;
-
-  instructionArgumentTypeMap[Instruction.LOAD_IMM_64] = ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
-
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U8] = ArgumentType.TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U16] = ArgumentType.TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U32] = ArgumentType.TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U64] = ArgumentType.TWO_IMMEDIATES;
-
-  instructionArgumentTypeMap[Instruction.JUMP] = ArgumentType.ONE_OFFSET;
-
-  instructionArgumentTypeMap[Instruction.JUMP_IND] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_I8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_I16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_I32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U8] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U16] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U32] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U64] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-
-  instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_EQ_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_NE_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-
-  instructionArgumentTypeMap[Instruction.MOVE_REG] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SBRK] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_64] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_32] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SIGN_EXTEND_8] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SIGN_EXTEND_16] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ZERO_EXTEND_16] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REVERSE_BYTES] = ArgumentType.TWO_REGISTERS;
-
-  instructionArgumentTypeMap[Instruction.STORE_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_I8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_I16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_I32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.AND_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.XOR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.OR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.MUL_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.MUL_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_LT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_LT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_GT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_GT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.CMOV_IZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.CMOV_NZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_64_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_64_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_32_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_32_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-
-  instructionArgumentTypeMap[Instruction.BRANCH_EQ] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_NE] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-
-  instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP_IND] = ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
-
-  instructionArgumentTypeMap[Instruction.ADD_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ADD_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SUB_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SUB_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.AND] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.XOR] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.OR] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_UPPER_S_S] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_UPPER_U_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_UPPER_S_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_U_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_S_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_U_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_S_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_U_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_S_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_U_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_S_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SET_LT_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SET_LT_S] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_L_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_R_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHAR_R_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_L_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_R_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHAR_R_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.CMOV_IZ] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.CMOV_NZ] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_L_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_L_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_R_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_R_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.AND_INV] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.OR_INV] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.XNOR] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MAX] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MAX_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MIN] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MIN_U] = ArgumentType.THREE_REGISTERS;
-
-  return instructionArgumentTypeMap;
-})();
-
 declare class BasicBlocks {
   private basicBlocks: Set<number> = new Set();
 
@@ -16515,6 +16758,11 @@ declare class BasicBlocks {
   }
 }
 
+/** Create a new gas counter instance depending on the gas value. */
+declare function gasCounter(gas: Gas): IGasCounter {
+  return new GasCounterU64(tryAsU64(gas));
+}
+
 declare enum Result {
   HALT = 0,
   PANIC = 1,
@@ -18267,66 +18515,6 @@ declare enum ProgramDecoderError {
   InvalidProgramError = 0,
 }
 
-declare class ProgramDecoder {
-  private code: Uint8Array;
-  private mask: Mask;
-  private jumpTable: JumpTable;
-
-  constructor(rawProgram: Uint8Array) {
-    const { code, mask, jumpTable, jumpTableItemLength } = this.decodeProgram(rawProgram);
-
-    this.code = new Uint8Array(code);
-    this.mask = new Mask(mask);
-    this.jumpTable = new JumpTable(jumpTableItemLength, jumpTable);
-  }
-
-  private decodeProgram(program: Uint8Array) {
-    const decoder = Decoder.fromBlob(program);
-    // number of items in the jump table
-    const jumpTableLength = decoder.varU32();
-    // how many bytes are used to encode a single item of the jump table
-    const jumpTableItemLength = decoder.u8();
-    // the length of the code (in bytes).
-    const codeLength = decoder.varU32();
-
-    const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;
-    const jumpTable = decoder.bytes(jumpTableLengthInBytes).raw;
-
-    const code = decoder.bytes(codeLength).raw;
-    const mask = decoder.bitVecFixLen(codeLength);
-    decoder.finish();
-
-    return {
-      mask,
-      code,
-      jumpTableItemLength,
-      jumpTable,
-    };
-  }
-
-  getMask() {
-    return this.mask;
-  }
-
-  getCode() {
-    return this.code;
-  }
-
-  getJumpTable() {
-    return this.jumpTable;
-  }
-
-  /** https://graypaper.fluffylabs.dev/#/68eaa1f/23f400234701?v=0.6.4 */
-  static deblob(program: Uint8Array): Result$2<ProgramDecoder, ProgramDecoderError> {
-    try {
-      return Result.ok(new ProgramDecoder(program));
-    } catch (e) {
-      logger.error`Invalid program: ${e}`;
-      return Result.error(ProgramDecoderError.InvalidProgramError, () => `Program decoder error: ${e}`);
-    }
-  }
-}
-
 type InterpreterOptions = {
   useSbrkGas?: boolean;
 };
@@ -18602,24 +18790,112 @@ declare class Interpreter implements IPvmInterpreter {
   }
 }
 
-type index$7_Interpreter = Interpreter;
-declare const index$7_Interpreter: typeof Interpreter;
-type index$7_InterpreterOptions = InterpreterOptions;
-type index$7_Memory = Memory;
-declare const index$7_Memory: typeof Memory;
-type index$7_MemoryBuilder = MemoryBuilder;
-declare const index$7_MemoryBuilder: typeof MemoryBuilder;
-type index$7_MemoryIndex = MemoryIndex;
-type index$7_Registers = Registers;
-declare const index$7_Registers: typeof Registers;
-type index$7_SbrkIndex = SbrkIndex;
-declare const index$7_gasCounter: typeof gasCounter;
-declare const index$7_logger: typeof logger;
-declare const index$7_tryAsMemoryIndex: typeof tryAsMemoryIndex;
-declare const index$7_tryAsSbrkIndex: typeof tryAsSbrkIndex;
-declare namespace index$7 {
-  export { index$7_Interpreter as Interpreter, index$7_Memory as Memory, index$7_MemoryBuilder as MemoryBuilder, index$7_Registers as Registers, index$7_gasCounter as gasCounter, index$7_logger as logger, index$7_tryAsMemoryIndex as tryAsMemoryIndex, index$7_tryAsSbrkIndex as tryAsSbrkIndex };
-  export type { index$7_InterpreterOptions as InterpreterOptions, index$7_MemoryIndex as MemoryIndex, index$7_SbrkIndex as SbrkIndex };
+declare class DebuggerAdapter {
+  private readonly pvm: Interpreter;
+
+  constructor(useSbrkGas = false) {
+    this.pvm = new Interpreter({ useSbrkGas });
+  }
+
+  resetGeneric(rawProgram: Uint8Array, flatRegisters: Uint8Array, initialGas: bigint) {
+    this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
+  }
+
+  reset(rawProgram: Uint8Array, pc: number, gas: bigint, maybeRegisters?: Registers, maybeMemory?: Memory) {
+    this.pvm.resetGeneric(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
+  }
+
+  getPageDump(pageNumber: number): null | Uint8Array {
+    const page = this.pvm.getMemoryPage(pageNumber);
+
+    if (page === null) {
+      // page wasn't allocated so we return an empty page
+      return safeAllocUint8Array(PAGE_SIZE);
+    }
+
+    if (page.length === PAGE_SIZE) {
+      // page was allocated and has a proper size so we can simply return it
+      return page;
+    }
+
+    // page was allocated but it is shorter than PAGE_SIZE so we have to extend it
+    const fullPage = safeAllocUint8Array(PAGE_SIZE);
+    fullPage.set(page);
+    return fullPage;
+  }
+
+  setMemory(address: number, value: Uint8Array) {
+    this.pvm.memory.storeFrom(tryAsMemoryIndex(address), value);
+  }
+
+  getExitArg(): number {
+    return this.pvm.getExitParam() ?? 0;
+  }
+
+  getStatus(): Status {
+    return this.pvm.getStatus();
+  }
+
+  nextStep(): boolean {
+    return this.pvm.nextStep() === Status.OK;
+  }
+
+  nSteps(steps: number): boolean {
+    check`${steps >>> 0 > 0} Expected a positive integer got ${steps}`;
+    for (let i = 0; i < steps; i++) {
+      const isOk = this.nextStep();
+      if (!isOk) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  getRegisters(): BigUint64Array {
+    return this.pvm.registers.getAllU64();
+  }
+
+  setRegisters(registers: Uint8Array) {
+    this.pvm.registers.copyFrom(new Registers(registers));
+  }
+
+  getProgramCounter(): number {
+    return this.pvm.getPC();
+  }
+
+  setNextProgramCounter(nextPc: number) {
+    this.pvm.setNextPC(nextPc);
+  }
+
+  getGasLeft(): bigint {
+    return BigInt(this.pvm.gas.get());
+  }
+
+  setGasLeft(gas: bigint) {
+    this.pvm.gas.set(tryAsGas(gas));
+  }
+}
+
+type index$6_DebuggerAdapter = DebuggerAdapter;
+declare const index$6_DebuggerAdapter: typeof DebuggerAdapter;
+type index$6_Interpreter = Interpreter;
+declare const index$6_Interpreter: typeof Interpreter;
+type index$6_InterpreterOptions = InterpreterOptions;
+type index$6_Memory = Memory;
+declare const index$6_Memory: typeof Memory;
+type index$6_MemoryBuilder = MemoryBuilder;
+declare const index$6_MemoryBuilder: typeof MemoryBuilder;
+type index$6_MemoryIndex = MemoryIndex;
+type index$6_Registers = Registers;
+declare const index$6_Registers: typeof Registers;
+type index$6_SbrkIndex = SbrkIndex;
+declare const index$6_gasCounter: typeof gasCounter;
+declare const index$6_logger: typeof logger;
+declare const index$6_tryAsMemoryIndex: typeof tryAsMemoryIndex;
+declare const index$6_tryAsSbrkIndex: typeof tryAsSbrkIndex;
+declare namespace index$6 {
+  export { index$6_DebuggerAdapter as DebuggerAdapter, index$6_Interpreter as Interpreter, index$6_Memory as Memory, index$6_MemoryBuilder as MemoryBuilder, index$6_Registers as Registers, index$6_gasCounter as gasCounter, index$6_logger as logger, index$6_tryAsMemoryIndex as tryAsMemoryIndex, index$6_tryAsSbrkIndex as tryAsSbrkIndex };
+  export type { index$6_InterpreterOptions as InterpreterOptions, index$6_MemoryIndex as MemoryIndex, index$6_SbrkIndex as SbrkIndex };
 }
 
 type ResolveFn = (pvm: IPvmInterpreter) => void;
@@ -18805,18 +19081,18 @@ declare class HostCalls {
   }
 }
 
-type index$6_HostCallHandler = HostCallHandler;
-type index$6_HostCallMemory = HostCallMemory;
-declare const index$6_HostCallMemory: typeof HostCallMemory;
-type index$6_HostCallRegisters = HostCallRegisters;
-declare const index$6_HostCallRegisters: typeof HostCallRegisters;
-type index$6_PvmExecution = PvmExecution;
-declare const index$6_PvmExecution: typeof PvmExecution;
-declare const index$6_traceRegisters: typeof traceRegisters;
-declare const index$6_tryAsHostCallIndex: typeof tryAsHostCallIndex;
-declare namespace index$6 {
-  export { index$6_HostCallMemory as HostCallMemory, index$6_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, index$6_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, index$6_traceRegisters as traceRegisters, index$6_tryAsHostCallIndex as tryAsHostCallIndex };
-  export type { index$6_HostCallHandler as HostCallHandler };
+type index$5_HostCallHandler = HostCallHandler;
+type index$5_HostCallMemory = HostCallMemory;
+declare const index$5_HostCallMemory: typeof HostCallMemory;
+type index$5_HostCallRegisters = HostCallRegisters;
+declare const index$5_HostCallRegisters: typeof HostCallRegisters;
+type index$5_PvmExecution = PvmExecution;
+declare const index$5_PvmExecution: typeof PvmExecution;
+declare const index$5_traceRegisters: typeof traceRegisters;
+declare const index$5_tryAsHostCallIndex: typeof tryAsHostCallIndex;
+declare namespace index$5 {
+  export { index$5_HostCallMemory as HostCallMemory, index$5_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, index$5_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, index$5_traceRegisters as traceRegisters, index$5_tryAsHostCallIndex as tryAsHostCallIndex };
+  export type { index$5_HostCallHandler as HostCallHandler };
 }
 
 /**
@@ -19178,7 +19454,11 @@ declare class PartiallyUpdatedState<T extends StateSlice = StateSlice> {
     return service?.getPreimage(hash) ?? null;
   }
 
-  /** Get status of a preimage of current service taking into account any updates. */
+  /**
+   * Get status of a preimage of current service taking into account any updates.
+   *
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/110201110201?v=0.7.2
+   */
   getLookupHistory(
     currentTimeslot: TimeSlot,
     serviceId: ServiceId,
@@ -19231,13 +19511,7 @@ declare class PartiallyUpdatedState<T extends StateSlice = StateSlice> {
         return new LookupHistoryItem(hash, updatedPreimage.length, tryAsLookupHistorySlots([currentTimeslot]));
       }
       case UpdatePreimageKind.Remove: {
-        const state = stateFallback();
-        // kinda impossible, since we know it's there because it's removed.
-        if (state === null) {
-          return null;
-        }
-
-        return new LookupHistoryItem(hash, state.length, tryAsLookupHistorySlots([...state.slots, currentTimeslot]));
+        return null;
       }
       case UpdatePreimageKind.UpdateOrAdd: {
         return action.item;
@@ -19456,184 +19730,14 @@ declare const codecServiceAccountInfoWithThresholdBalance = codec.object(
   "ServiceAccountInfoWithThresholdBalance",
 );
 
-type index$5_AccumulationStateUpdate = AccumulationStateUpdate;
-declare const index$5_AccumulationStateUpdate: typeof AccumulationStateUpdate;
-declare const index$5_CURRENT_SERVICE_ID: typeof CURRENT_SERVICE_ID;
-type index$5_EjectError = EjectError;
-declare const index$5_EjectError: typeof EjectError;
-type index$5_ForgetPreimageError = ForgetPreimageError;
-declare const index$5_ForgetPreimageError: typeof ForgetPreimageError;
-declare const index$5_HostCallResult: typeof HostCallResult;
-type index$5_InsufficientFundsError = InsufficientFundsError;
-declare const index$5_MAX_U32: typeof MAX_U32;
-declare const index$5_MAX_U32_BIG_INT: typeof MAX_U32_BIG_INT;
-type index$5_MachineId = MachineId;
-type index$5_MachineInstance = MachineInstance;
-declare const index$5_MachineInstance: typeof MachineInstance;
-type index$5_MachineResult = MachineResult;
-type index$5_MachineStatus = MachineStatus;
-type index$5_MemoryOperation = MemoryOperation;
-declare const index$5_MemoryOperation: typeof MemoryOperation;
-type index$5_NewServiceError = NewServiceError;
-declare const index$5_NewServiceError: typeof NewServiceError;
-type index$5_NoMachineError = NoMachineError;
-type index$5_PagesError = PagesError;
-declare const index$5_PagesError: typeof PagesError;
-type index$5_PartialState = PartialState;
-type index$5_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
-declare const index$5_PartiallyUpdatedState: typeof PartiallyUpdatedState;
-type index$5_PeekPokeError = PeekPokeError;
-declare const index$5_PeekPokeError: typeof PeekPokeError;
-type index$5_PendingTransfer = PendingTransfer;
-declare const index$5_PendingTransfer: typeof PendingTransfer;
-type index$5_PreimageStatus = PreimageStatus;
-type index$5_PreimageStatusKind = PreimageStatusKind;
-declare const index$5_PreimageStatusKind: typeof PreimageStatusKind;
-type index$5_ProgramCounter = ProgramCounter;
-type index$5_ProvidePreimageError = ProvidePreimageError;
-declare const index$5_ProvidePreimageError: typeof ProvidePreimageError;
-type index$5_RefineExternalities = RefineExternalities;
-type index$5_RequestPreimageError = RequestPreimageError;
-declare const index$5_RequestPreimageError: typeof RequestPreimageError;
-declare const index$5_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
-type index$5_SegmentExportError = SegmentExportError;
-type index$5_ServiceStateUpdate = ServiceStateUpdate;
-type index$5_StateSlice = StateSlice;
-type index$5_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
-type index$5_TransferError = TransferError;
-declare const index$5_TransferError: typeof TransferError;
-type index$5_UnprivilegedError = UnprivilegedError;
-type index$5_UpdatePrivilegesError = UpdatePrivilegesError;
-declare const index$5_UpdatePrivilegesError: typeof UpdatePrivilegesError;
-type index$5_ZeroVoidError = ZeroVoidError;
-declare const index$5_ZeroVoidError: typeof ZeroVoidError;
-declare const index$5_clampU64ToU32: typeof clampU64ToU32;
-declare const index$5_deepCloneMapWithArray: typeof deepCloneMapWithArray;
-declare const index$5_emptyRegistersBuffer: typeof emptyRegistersBuffer;
-declare const index$5_getServiceId: typeof getServiceId;
-declare const index$5_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
-declare const index$5_preimageLenAsU32: typeof preimageLenAsU32;
-declare const index$5_slotsToPreimageStatus: typeof slotsToPreimageStatus;
-declare const index$5_toMemoryOperation: typeof toMemoryOperation;
-declare const index$5_tryAsMachineId: typeof tryAsMachineId;
-declare const index$5_tryAsProgramCounter: typeof tryAsProgramCounter;
-declare const index$5_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
-declare namespace index$5 {
-  export { index$5_AccumulationStateUpdate as AccumulationStateUpdate, index$5_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$5_EjectError as EjectError, index$5_ForgetPreimageError as ForgetPreimageError, index$5_HostCallResult as HostCallResult, index$5_MAX_U32 as MAX_U32, index$5_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$5_MachineInstance as MachineInstance, index$5_MemoryOperation as MemoryOperation, index$5_NewServiceError as NewServiceError, index$5_PagesError as PagesError, index$5_PartiallyUpdatedState as PartiallyUpdatedState, index$5_PeekPokeError as PeekPokeError, index$5_PendingTransfer as PendingTransfer, index$5_PreimageStatusKind as PreimageStatusKind, index$5_ProvidePreimageError as ProvidePreimageError, index$5_RequestPreimageError as RequestPreimageError, index$5_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$5_TransferError as TransferError, index$5_UpdatePrivilegesError as UpdatePrivilegesError, index$5_ZeroVoidError as ZeroVoidError, index$5_clampU64ToU32 as clampU64ToU32, index$5_deepCloneMapWithArray as deepCloneMapWithArray, index$5_emptyRegistersBuffer as emptyRegistersBuffer, index$5_getServiceId as getServiceId, index$5_getServiceIdOrCurrent as getServiceIdOrCurrent, codecServiceAccountInfoWithThresholdBalance as hostCallInfoAccount, index$5_preimageLenAsU32 as preimageLenAsU32, index$5_slotsToPreimageStatus as slotsToPreimageStatus, index$5_toMemoryOperation as toMemoryOperation, index$5_tryAsMachineId as tryAsMachineId, index$5_tryAsProgramCounter as tryAsProgramCounter, index$5_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
-  export type { index$5_InsufficientFundsError as InsufficientFundsError, index$5_MachineId as MachineId, index$5_MachineResult as MachineResult, index$5_MachineStatus as MachineStatus, index$5_NoMachineError as NoMachineError, index$5_PartialState as PartialState, index$5_PreimageStatus as PreimageStatus, index$5_ProgramCounter as ProgramCounter, index$5_RefineExternalities as RefineExternalities, index$5_SegmentExportError as SegmentExportError, index$5_ServiceStateUpdate as ServiceStateUpdate, index$5_StateSlice as StateSlice, index$5_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$5_UnprivilegedError as UnprivilegedError };
-}
-
-declare class DebuggerAdapter {
-  private readonly pvm: Interpreter;
-
-  constructor(useSbrkGas = false) {
-    this.pvm = new Interpreter({ useSbrkGas });
-  }
-
-  resetGeneric(rawProgram: Uint8Array, flatRegisters: Uint8Array, initialGas: bigint) {
-    this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
-  }
-
-  reset(rawProgram: Uint8Array, pc: number, gas: bigint, maybeRegisters?: Registers, maybeMemory?: Memory) {
-    this.pvm.resetGeneric(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
-  }
-
-  getPageDump(pageNumber: number): null | Uint8Array {
-    const page = this.pvm.getMemoryPage(pageNumber);
-
-    if (page === null) {
-      // page wasn't allocated so we return an empty page
-      return safeAllocUint8Array(PAGE_SIZE);
-    }
-
-    if (page.length === PAGE_SIZE) {
-      // page was allocated and has a proper size so we can simply return it
-      return page;
-    }
-
-    // page was allocated but it is shorter than PAGE_SIZE so we have to extend it
-    const fullPage = safeAllocUint8Array(PAGE_SIZE);
-    fullPage.set(page);
-    return fullPage;
-  }
-
-  setMemory(address: number, value: Uint8Array) {
-    this.pvm.memory.storeFrom(tryAsMemoryIndex(address), value);
-  }
-
-  getExitArg(): number {
-    return this.pvm.getExitParam() ?? 0;
-  }
-
-  getStatus(): Status {
-    return this.pvm.getStatus();
-  }
-
-  nextStep(): boolean {
-    return this.pvm.nextStep() === Status.OK;
-  }
-
-  nSteps(steps: number): boolean {
-    check`${steps >>> 0 > 0} Expected a positive integer got ${steps}`;
-    for (let i = 0; i < steps; i++) {
-      const isOk = this.nextStep();
-      if (!isOk) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  getRegisters(): BigUint64Array {
-    return this.pvm.registers.getAllU64();
-  }
-
-  setRegisters(registers: Uint8Array) {
-    this.pvm.registers.copyFrom(new Registers(registers));
-  }
-
-  getProgramCounter(): number {
-    return this.pvm.getPC();
-  }
-
-  setNextProgramCounter(nextPc: number) {
-    this.pvm.setNextPC(nextPc);
-  }
-
-  getGasLeft(): bigint {
-    return BigInt(this.pvm.gas.get());
-  }
-
-  setGasLeft(gas: bigint) {
-    this.pvm.gas.set(tryAsGas(gas));
-  }
-}
-
 type index$4_AccumulationStateUpdate = AccumulationStateUpdate;
 declare const index$4_AccumulationStateUpdate: typeof AccumulationStateUpdate;
-type index$4_Args = Args;
-type index$4_ArgsDecoder = ArgsDecoder;
-declare const index$4_ArgsDecoder: typeof ArgsDecoder;
-type index$4_ArgumentType = ArgumentType;
-declare const index$4_ArgumentType: typeof ArgumentType;
-type index$4_BasicBlocks = BasicBlocks;
-declare const index$4_BasicBlocks: typeof BasicBlocks;
 declare const index$4_CURRENT_SERVICE_ID: typeof CURRENT_SERVICE_ID;
 type index$4_EjectError = EjectError;
 declare const index$4_EjectError: typeof EjectError;
-type index$4_EnumMapping = EnumMapping;
-type index$4_ErrorResult<Error> = ErrorResult<Error>;
-type index$4_ExtendedWitdthImmediateDecoder = ExtendedWitdthImmediateDecoder;
-declare const index$4_ExtendedWitdthImmediateDecoder: typeof ExtendedWitdthImmediateDecoder;
 type index$4_ForgetPreimageError = ForgetPreimageError;
 declare const index$4_ForgetPreimageError: typeof ForgetPreimageError;
-type index$4_HostCallMemory = HostCallMemory;
-declare const index$4_HostCallMemory: typeof HostCallMemory;
-type index$4_HostCallRegisters = HostCallRegisters;
-declare const index$4_HostCallRegisters: typeof HostCallRegisters;
 declare const index$4_HostCallResult: typeof HostCallResult;
-type index$4_ImmediateDecoder = ImmediateDecoder;
-declare const index$4_ImmediateDecoder: typeof ImmediateDecoder;
 type index$4_InsufficientFundsError = InsufficientFundsError;
 declare const index$4_MAX_U32: typeof MAX_U32;
 declare const index$4_MAX_U32_BIG_INT: typeof MAX_U32_BIG_INT;
@@ -19642,20 +19746,11 @@ type index$4_MachineInstance = MachineInstance;
 declare const index$4_MachineInstance: typeof MachineInstance;
 type index$4_MachineResult = MachineResult;
 type index$4_MachineStatus = MachineStatus;
-type index$4_Mask = Mask;
-declare const index$4_Mask: typeof Mask;
 type index$4_MemoryOperation = MemoryOperation;
 declare const index$4_MemoryOperation: typeof MemoryOperation;
-type index$4_MemorySegment = MemorySegment;
-declare const index$4_MemorySegment: typeof MemorySegment;
 type index$4_NewServiceError = NewServiceError;
 declare const index$4_NewServiceError: typeof NewServiceError;
-type index$4_NibblesDecoder = NibblesDecoder;
-declare const index$4_NibblesDecoder: typeof NibblesDecoder;
 type index$4_NoMachineError = NoMachineError;
-type index$4_OK = OK;
-type index$4_OkResult<Ok> = OkResult<Ok>;
-type index$4_Opaque<Type, Token extends string> = Opaque<Type, Token>;
 type index$4_PagesError = PagesError;
 declare const index$4_PagesError: typeof PagesError;
 type index$4_PartialState = PartialState;
@@ -19668,74 +19763,38 @@ declare const index$4_PendingTransfer: typeof PendingTransfer;
 type index$4_PreimageStatus = PreimageStatus;
 type index$4_PreimageStatusKind = PreimageStatusKind;
 declare const index$4_PreimageStatusKind: typeof PreimageStatusKind;
-type index$4_Program = Program;
-declare const index$4_Program: typeof Program;
 type index$4_ProgramCounter = ProgramCounter;
-type index$4_ProgramDecoder = ProgramDecoder;
-declare const index$4_ProgramDecoder: typeof ProgramDecoder;
 type index$4_ProvidePreimageError = ProvidePreimageError;
 declare const index$4_ProvidePreimageError: typeof ProvidePreimageError;
 type index$4_RefineExternalities = RefineExternalities;
-type index$4_Registers = Registers;
-declare const index$4_Registers: typeof Registers;
 type index$4_RequestPreimageError = RequestPreimageError;
 declare const index$4_RequestPreimageError: typeof RequestPreimageError;
-type index$4_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
-declare const index$4_RichTaggedError: typeof RichTaggedError;
 declare const index$4_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
 type index$4_SegmentExportError = SegmentExportError;
 type index$4_ServiceStateUpdate = ServiceStateUpdate;
-type index$4_SpiMemory = SpiMemory;
-declare const index$4_SpiMemory: typeof SpiMemory;
-type index$4_SpiProgram = SpiProgram;
-declare const index$4_SpiProgram: typeof SpiProgram;
 type index$4_StateSlice = StateSlice;
-type index$4_StringLiteral<Type> = StringLiteral<Type>;
 type index$4_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
-type index$4_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
-type index$4_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
 type index$4_TransferError = TransferError;
 declare const index$4_TransferError: typeof TransferError;
-type index$4_Uninstantiable = Uninstantiable;
 type index$4_UnprivilegedError = UnprivilegedError;
 type index$4_UpdatePrivilegesError = UpdatePrivilegesError;
 declare const index$4_UpdatePrivilegesError: typeof UpdatePrivilegesError;
-type index$4_WithDebug = WithDebug;
-declare const index$4_WithDebug: typeof WithDebug;
-type index$4_WithOpaque<Token extends string> = WithOpaque<Token>;
 type index$4_ZeroVoidError = ZeroVoidError;
 declare const index$4_ZeroVoidError: typeof ZeroVoidError;
-declare const index$4___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
-declare const index$4_asOpaqueType: typeof asOpaqueType;
-declare const index$4_assertEmpty: typeof assertEmpty;
-declare const index$4_assertNever: typeof assertNever;
-declare const index$4_check: typeof check;
 declare const index$4_clampU64ToU32: typeof clampU64ToU32;
-declare const index$4_createResults: typeof createResults;
-declare const index$4_decodeStandardProgram: typeof decodeStandardProgram;
 declare const index$4_deepCloneMapWithArray: typeof deepCloneMapWithArray;
 declare const index$4_emptyRegistersBuffer: typeof emptyRegistersBuffer;
-declare const index$4_extractCodeAndMetadata: typeof extractCodeAndMetadata;
 declare const index$4_getServiceId: typeof getServiceId;
 declare const index$4_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
-declare const index$4_inspect: typeof inspect;
-declare const index$4_instructionArgumentTypeMap: typeof instructionArgumentTypeMap;
-declare const index$4_isBrowser: typeof isBrowser;
-declare const index$4_isTaggedError: typeof isTaggedError;
-declare const index$4_lazyInspect: typeof lazyInspect;
-declare const index$4_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
-declare const index$4_measure: typeof measure;
 declare const index$4_preimageLenAsU32: typeof preimageLenAsU32;
-declare const index$4_resultToString: typeof resultToString;
-declare const index$4_seeThrough: typeof seeThrough;
 declare const index$4_slotsToPreimageStatus: typeof slotsToPreimageStatus;
 declare const index$4_toMemoryOperation: typeof toMemoryOperation;
 declare const index$4_tryAsMachineId: typeof tryAsMachineId;
 declare const index$4_tryAsProgramCounter: typeof tryAsProgramCounter;
 declare const index$4_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$4 {
-  export { index$4_AccumulationStateUpdate as AccumulationStateUpdate, index$4_ArgsDecoder as ArgsDecoder, index$4_ArgumentType as ArgumentType, index$4_BasicBlocks as BasicBlocks, index$4_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$4_EjectError as EjectError, index$4_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$4_ForgetPreimageError as ForgetPreimageError, index$4_HostCallMemory as HostCallMemory, index$4_HostCallRegisters as HostCallRegisters, index$4_HostCallResult as HostCallResult, index$4_ImmediateDecoder as ImmediateDecoder, index$4_MAX_U32 as MAX_U32, index$4_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$4_MachineInstance as MachineInstance, index$4_Mask as Mask, index$4_MemoryOperation as MemoryOperation, index$4_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$4_NewServiceError as NewServiceError, index$4_NibblesDecoder as NibblesDecoder, index$4_PagesError as PagesError, index$4_PartiallyUpdatedState as PartiallyUpdatedState, index$4_PeekPokeError as PeekPokeError, index$4_PendingTransfer as PendingTransfer, index$4_PreimageStatusKind as PreimageStatusKind, index$4_Program as Program, index$4_ProgramDecoder as ProgramDecoder, index$4_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$4_Registers as Registers, index$4_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$4_RichTaggedError as RichTaggedError, index$4_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$4_SpiMemory as SpiMemory, index$4_SpiProgram as SpiProgram, index$4_TransferError as TransferError, index$4_UpdatePrivilegesError as UpdatePrivilegesError, index$4_WithDebug as WithDebug, index$4_ZeroVoidError as ZeroVoidError, index$4___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$4_asOpaqueType as asOpaqueType, index$4_assertEmpty as assertEmpty, index$4_assertNever as assertNever, index$m as block, index$t as bytes, index$4_check as check, index$4_clampU64ToU32 as clampU64ToU32, index$4_createResults as createResults, index$4_decodeStandardProgram as decodeStandardProgram, index$4_deepCloneMapWithArray as deepCloneMapWithArray, index$4_emptyRegistersBuffer as emptyRegistersBuffer, index$4_extractCodeAndMetadata as extractCodeAndMetadata, index$4_getServiceId as getServiceId, index$4_getServiceIdOrCurrent as getServiceIdOrCurrent, index$q as hash, codecServiceAccountInfoWithThresholdBalance as hostCallInfoAccount, index$4_inspect as inspect, index$4_instructionArgumentTypeMap as instructionArgumentTypeMap, index$7 as interpreter, index$4_isBrowser as isBrowser, index$4_isTaggedError as isTaggedError, index$4_lazyInspect as lazyInspect, index$4_maybeTaggedErrorToString as maybeTaggedErrorToString, index$4_measure as measure, index$s as numbers, index$4_preimageLenAsU32 as preimageLenAsU32, index$4_resultToString as resultToString, index$4_seeThrough as seeThrough, index$4_slotsToPreimageStatus as slotsToPreimageStatus, index$4_toMemoryOperation as toMemoryOperation, index$4_tryAsMachineId as tryAsMachineId, index$4_tryAsProgramCounter as tryAsProgramCounter, index$4_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
-  export type { index$4_Args as Args, index$4_EnumMapping as EnumMapping, index$4_ErrorResult as ErrorResult, index$4_InsufficientFundsError as InsufficientFundsError, index$4_MachineId as MachineId, index$4_MachineResult as MachineResult, index$4_MachineStatus as MachineStatus, index$4_NoMachineError as NoMachineError, index$4_OK as OK, index$4_OkResult as OkResult, index$4_Opaque as Opaque, index$4_PartialState as PartialState, index$4_PreimageStatus as PreimageStatus, index$4_ProgramCounter as ProgramCounter, index$4_RefineExternalities as RefineExternalities, index$4_SegmentExportError as SegmentExportError, index$4_ServiceStateUpdate as ServiceStateUpdate, index$4_StateSlice as StateSlice, index$4_StringLiteral as StringLiteral, index$4_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$4_TaggedError as TaggedError, index$4_TokenOf as TokenOf, index$4_Uninstantiable as Uninstantiable, index$4_UnprivilegedError as UnprivilegedError, index$4_WithOpaque as WithOpaque };
+  export { index$4_AccumulationStateUpdate as AccumulationStateUpdate, index$4_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$4_EjectError as EjectError, index$4_ForgetPreimageError as ForgetPreimageError, index$4_HostCallResult as HostCallResult, index$4_MAX_U32 as MAX_U32, index$4_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$4_MachineInstance as MachineInstance, index$4_MemoryOperation as MemoryOperation, index$4_NewServiceError as NewServiceError, index$4_PagesError as PagesError, index$4_PartiallyUpdatedState as PartiallyUpdatedState, index$4_PeekPokeError as PeekPokeError, index$4_PendingTransfer as PendingTransfer, index$4_PreimageStatusKind as PreimageStatusKind, index$4_ProvidePreimageError as ProvidePreimageError, index$4_RequestPreimageError as RequestPreimageError, index$4_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$4_TransferError as TransferError, index$4_UpdatePrivilegesError as UpdatePrivilegesError, index$4_ZeroVoidError as ZeroVoidError, index$4_clampU64ToU32 as clampU64ToU32, index$4_deepCloneMapWithArray as deepCloneMapWithArray, index$4_emptyRegistersBuffer as emptyRegistersBuffer, index$4_getServiceId as getServiceId, index$4_getServiceIdOrCurrent as getServiceIdOrCurrent, codecServiceAccountInfoWithThresholdBalance as hostCallInfoAccount, index$4_preimageLenAsU32 as preimageLenAsU32, index$4_slotsToPreimageStatus as slotsToPreimageStatus, index$4_toMemoryOperation as toMemoryOperation, index$4_tryAsMachineId as tryAsMachineId, index$4_tryAsProgramCounter as tryAsProgramCounter, index$4_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export type { index$4_InsufficientFundsError as InsufficientFundsError, index$4_MachineId as MachineId, index$4_MachineResult as MachineResult, index$4_MachineStatus as MachineStatus, index$4_NoMachineError as NoMachineError, index$4_PartialState as PartialState, index$4_PreimageStatus as PreimageStatus, index$4_ProgramCounter as ProgramCounter, index$4_RefineExternalities as RefineExternalities, index$4_SegmentExportError as SegmentExportError, index$4_ServiceStateUpdate as ServiceStateUpdate, index$4_StateSlice as StateSlice, index$4_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$4_UnprivilegedError as UnprivilegedError };
 }
 
 declare const ENTROPY_BYTES = 32;
@@ -20539,7 +20598,6 @@ declare namespace index$1 {
 /** Helper function to create most used hashes in the block */
 declare class TransitionHasher implements MmrHasher<KeccakHash> {
   constructor(
-    private readonly context: ChainSpec,
     private readonly keccakHasher: KeccakHasher,
     public readonly blake2b: Blake2b,
   ) {}
@@ -20695,4 +20753,4 @@ declare namespace index {
   export type { index_PreimagesInput as PreimagesInput, index_PreimagesState as PreimagesState, index_PreimagesStateUpdate as PreimagesStateUpdate };
 }
 
-export { index$m as block, index$k as block_json, index$t as bytes, index$r as codec, index$p as collections, index$n as config, index$i as config_node, index$o as crypto, index$d as database, index$c as erasure_coding, index$a as fuzz_proto, index$q as hash, index$5 as jam_host_calls, index$l as json_parser, index$j as logger, index$g as mmr, index$s as numbers, index$u as ordering, index$4 as pvm, index$6 as pvm_host_calls, index$7 as pvm_interpreter, index$8 as pvm_program, index$9 as pvm_spi_decoder, index$3 as shuffling, index$f as state, index$2 as state_json, index$e as state_merkleization, index$1 as state_vectors, index as transition, index$h as trie, index$v as utils };
+export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$o as collections, index$m as config, index$h as config_node, index$n as crypto, index$c as database, index$b as erasure_coding, index$9 as fuzz_proto, index$p as hash, index$4 as jam_host_calls, index$k as json_parser, index$i as logger, index$f as mmr, index$r as numbers, index$t as ordering, index$6 as pvm, index$5 as pvm_host_calls, index$7 as pvm_program, index$8 as pvm_spi_decoder, index$3 as shuffling, index$e as state, index$2 as state_json, index$d as state_merkleization, index$1 as state_vectors, index as transition, index$g as trie, index$u as utils };