@typeberry/lib 0.2.0-5746fdc → 0.2.0-663eeb1

package/index.d.ts

@@ -2,7 +2,7 @@ declare enum GpVersion {
   V0_6_7 = "0.6.7",
   V0_7_0 = "0.7.0",
   V0_7_1 = "0.7.1",
-  V0_7_2 = "0.7.2-preview",
+  V0_7_2 = "0.7.2",
 }
 
 declare enum TestSuite {
@@ -10,43 +10,39 @@ declare enum TestSuite {
   JAMDUNA = "jamduna",
 }
 
+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_1;
+declare const DEFAULT_VERSION = GpVersion.V0_7_2;
 declare let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 declare let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
 
-declare const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
-
 declare function parseCurrentVersion(env?: string): GpVersion | undefined {
   if (env === undefined) {
     return undefined;
   }
-  switch (env) {
-    case GpVersion.V0_6_7:
-    case GpVersion.V0_7_0:
-    case GpVersion.V0_7_1:
-    case GpVersion.V0_7_2:
-      return env;
-    default:
-      throw new Error(
-        `Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`,
-      );
+  for (const v of Object.values(GpVersion)) {
+    if (env === v) {
+      return v;
+    }
   }
+  throw new Error(
+    `Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`,
+  );
 }
 
 declare function parseCurrentSuite(env?: string): TestSuite | undefined {
   if (env === undefined) {
     return undefined;
   }
-  switch (env) {
-    case TestSuite.W3F_DAVXY:
-    case TestSuite.JAMDUNA:
-      return env;
-    default:
-      throw new Error(
-        `Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`,
-      );
+  for (const s of Object.values(TestSuite)) {
+    if (env === s) {
+      return s;
+    }
   }
+  throw new Error(
+    `Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`,
+  );
 }
 
 declare class Compatibility {
@@ -242,6 +238,14 @@ declare abstract class WithDebug {
   }
 }
 
+declare function lazyInspect<T>(obj: T) {
+  return {
+    toString() {
+      return inspect(obj);
+    },
+  };
+}
+
 /**
  * The function will produce relative path resolver that is adjusted
  * for package location within the workspace.
@@ -292,8 +296,7 @@ type Uninstantiable = void & { __brand: "uninstantiable" };
 
 type StringLiteral<Type> = Type extends string ? (string extends Type ? never : Type) : never;
 
-// TODO [MaSi]: it should be "unique symbol" but in debugger adapter we have opaque types from different packages and it is problematic.
-declare const __OPAQUE_TYPE__ = "__INTERNAL_OPAQUE_ID__";
+declare const __OPAQUE_TYPE__: unique symbol;
 
 type WithOpaque<Token extends string> = {
   readonly [__OPAQUE_TYPE__]: Token;
@@ -728,60 +731,61 @@ declare function isResult(x: unknown): x is Result$2<unknown, unknown> {
  * as an afterthought.
  */
 
-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_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_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 };
+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 };
 }
 
 /** A return value of some comparator. */
@@ -834,14 +838,14 @@ declare class Ordering {
  */
 type Comparator<V> = (self: V, other: V) => Ordering;
 
-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 };
+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 };
 }
 
 // TODO: [MaSo] Update BytesBlob and Bytes, so they return Result (not throw error)
@@ -873,12 +877,13 @@ declare class BytesBlob {
 
   /** Display a hex-encoded version of this byte blob, but truncated if it's large. */
   toStringTruncated() {
+    const bytes = `${this.raw.length} ${this.raw.length === 1 ? "byte" : "bytes"}`;
     if (this.raw.length > 32) {
       const start = bytesToHexString(this.raw.subarray(0, 16));
       const end = bytesToHexString(this.raw.subarray(this.raw.length - 16));
-      return `${start}...${end.substring(2)} (${this.raw.length} bytes)`;
+      return `${start}...${end.substring(2)} (${bytes})`;
     }
-    return this.toString();
+    return `${this.toString()} (${bytes})`;
   }
 
   toJSON() {
@@ -1234,53 +1239,50 @@ declare class BitVec {
   }
 }
 
-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 {
+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 {
   export {
-    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,
+    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,
   };
 }
 
-/**
- * TODO [ToDr] This should be `unique symbol`, but for some reason
- * I can't figure out how to build `@typeberry/blocks` package.
- */
-declare const __REPRESENTATION_BYTES__: "REPRESENTATION_BYTES";
+declare const __REPRESENTATION_BYTES__: unique symbol;
 
 type WithBytesRepresentation<Bytes extends number> = {
   readonly [__REPRESENTATION_BYTES__]: Bytes;
 };
+
 declare const asTypedNumber = <T, N extends number>(v: T): T & WithBytesRepresentation<N> =>
   v as T & WithBytesRepresentation<N>;
 
@@ -1416,37 +1418,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$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 };
+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 };
 }
 
 /** A decoder for some specific type `T` */
@@ -3468,53 +3470,53 @@ declare function sequenceViewFixLen<T, V>(
   );
 }
 
-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 };
+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 };
 }
 
 /**
@@ -3735,23 +3737,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$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 };
+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 };
 }
 
 /** Immutable view of the `HashDictionary`. */
@@ -4528,37 +4530,37 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 }
 
-type index$o_ArrayView<T> = ArrayView<T>;
-declare const index$o_ArrayView: typeof ArrayView;
-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_HashWithZeroedBit<T extends OpaqueHash> = HashWithZeroedBit<T>;
-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_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_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_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_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
-declare const index$o_TruncatedHashDictionary: typeof TruncatedHashDictionary;
-declare const index$o_asKnownSize: typeof asKnownSize;
-declare namespace index$o {
-  export { index$o_ArrayView as ArrayView, index$o_FixedSizeArray as FixedSizeArray, index$o_HashDictionary as HashDictionary, index$o_HashSet as HashSet, index$o_MultiMap as MultiMap, index$o_SortedArray as SortedArray, index$o_SortedSet as SortedSet, index$o_TruncatedHashDictionary as TruncatedHashDictionary, index$o_asKnownSize as asKnownSize };
-  export type { index$o_HashWithZeroedBit as HashWithZeroedBit, index$o_ImmutableHashDictionary as ImmutableHashDictionary, index$o_ImmutableHashSet as ImmutableHashSet, index$o_ImmutableSortedArray as ImmutableSortedArray, index$o_ImmutableSortedSet as ImmutableSortedSet, 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_NestedMaps as NestedMaps };
+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 };
 }
 
 declare namespace bandersnatch_d_exports {
@@ -4918,32 +4920,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$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 };
+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 };
 }
 
 /**
@@ -4984,6 +4986,8 @@ declare const EC_SEGMENT_SIZE = 4104;
  * Additional data that has to be passed to the codec to correctly parse incoming bytes.
  */
 declare class ChainSpec extends WithDebug {
+  /** Human-readable name of the chain spec. */
+  readonly name: string;
   /** Number of validators. */
   readonly validatorsCount: U16;
   /** 1/3 of number of validators */
@@ -5028,6 +5032,7 @@ declare class ChainSpec extends WithDebug {
   constructor(data: Omit<ChainSpec, "validatorsSuperMajority" | "thirdOfValidators" | "erasureCodedPieceSize">) {
     super();
 
+    this.name = data.name;
     this.validatorsCount = data.validatorsCount;
     this.thirdOfValidators = tryAsU16(Math.floor(data.validatorsCount / 3));
     this.validatorsSuperMajority = tryAsU16(Math.floor(data.validatorsCount / 3) * 2 + 1);
@@ -5049,6 +5054,7 @@ declare class ChainSpec extends WithDebug {
 
 /** Set of values for "tiny" chain as defined in JAM test vectors. */
 declare const tinyChainSpec = new ChainSpec({
+  name: "tiny",
   validatorsCount: tryAsU16(6),
   coresCount: tryAsU16(2),
   epochLength: tryAsU32(12),
@@ -5071,6 +5077,7 @@ declare const tinyChainSpec = new ChainSpec({
  * Please note that only validatorsCount and epochLength are "full", the rest is copied from "tiny".
  */
 declare const fullChainSpec = new ChainSpec({
+  name: "full",
   validatorsCount: tryAsU16(1023),
   coresCount: tryAsU16(341),
   epochLength: tryAsU32(600),
@@ -5128,25 +5135,25 @@ declare enum PvmBackend {
   Ananas = 1,
 }
 
-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 };
+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 };
 }
 
 /**
@@ -6952,74 +6959,74 @@ declare function reencodeAsView<T, V>(codec: Descriptor<T, V>, object: T, chainS
   return Decoder.decodeObject(codec.View, encoded, chainSpec);
 }
 
-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 };
+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 };
 }
 
 /** A type that can be read from a JSON-parsed object. */
@@ -7317,21 +7324,21 @@ declare namespace json {
   }
 }
 
-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 };
+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 };
 }
 
 declare namespace fromJson {
@@ -7834,52 +7841,52 @@ declare const blockFromJson = (spec: ChainSpec) =>
     ({ header, extrinsic }) => Block.create({ header, extrinsic }),
   );
 
-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 };
+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 };
 }
 
 declare function parseBootnode(v: string): Bootnode {
@@ -8127,16 +8134,16 @@ declare class Logger {
   }
 }
 
-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 {
+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 {
   export {
-    index$i_Level as Level,
-    index$i_Logger as Logger,
-    index$i_parseLoggerOptions as parseLoggerOptions,
+    index$j_Level as Level,
+    index$j_Logger as Logger,
+    index$j_parseLoggerOptions as parseLoggerOptions,
   };
 }
 
@@ -8168,8 +8175,8 @@ declare const DEFAULT_CONFIG = "default";
 
 declare const NODE_DEFAULTS = {
   name: isBrowser() ? "browser" : os.hostname(),
-  config: DEFAULT_CONFIG,
-  pvm: PvmBackend.BuiltIn,
+  config: [DEFAULT_CONFIG],
+  pvm: PvmBackend.Ananas,
 };
 
 /** Chain spec chooser. */
@@ -8222,52 +8229,173 @@ declare class NodeConfiguration {
   ) {}
 }
 
-declare function loadConfig(configPath: string): NodeConfiguration {
-  if (configPath === DEFAULT_CONFIG) {
-    logger.log`🔧 Loading DEFAULT config`;
-    return parseFromJson(configs.default, NodeConfiguration.fromJson);
-  }
+declare function loadConfig(config: string[], withRelPath: (p: string) => string): NodeConfiguration {
+  logger.log`🔧 Loading config`;
+  let mergedJson: AnyJsonObject = {};
+
+  for (const entry of config) {
+    logger.log`🔧 Applying '${entry}'`;
+
+    if (entry === DEV_CONFIG) {
+      mergedJson = structuredClone(configs.dev); // clone to avoid mutating the original config. not doing a merge since dev and default should theoretically replace all properties.
+      continue;
+    }
+
+    if (entry === DEFAULT_CONFIG) {
+      mergedJson = structuredClone(configs.default);
+      continue;
+    }
 
-  if (configPath === DEV_CONFIG) {
-    logger.log`🔧 Loading DEV config`;
-    return parseFromJson(configs.dev, NodeConfiguration.fromJson);
+    // try to parse as JSON
+    try {
+      const parsed = JSON.parse(entry);
+      deepMerge(mergedJson, parsed);
+      continue;
+    } catch {}
+
+    // if not, try to load as file
+    if (entry.indexOf("=") === -1 && entry.endsWith(".json")) {
+      try {
+        const configFile = fs.readFileSync(withRelPath(entry), "utf8");
+        const parsed = JSON.parse(configFile);
+        deepMerge(mergedJson, parsed);
+      } catch (e) {
+        throw new Error(`Unable to load config from ${entry}: ${e}`);
+      }
+    } else {
+      // finally try to process as a pseudo-jq query
+      try {
+        processQuery(mergedJson, entry, withRelPath);
+      } catch (e) {
+        throw new Error(`Error while processing '${entry}': ${e}`);
+      }
+    }
   }
 
   try {
-    logger.log`🔧 Loading config from ${configPath}`;
-    const configFile = fs.readFileSync(configPath, "utf8");
-    const parsed = JSON.parse(configFile);
-    return parseFromJson(parsed, NodeConfiguration.fromJson);
+    const parsed = parseFromJson(mergedJson, NodeConfiguration.fromJson);
+    logger.log`🔧 Config ready`;
+    return parsed;
   } catch (e) {
-    throw new Error(`Unable to load config file from ${configPath}: ${e}`);
-  }
-}
-
-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_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_knownChainSpecFromJson: typeof knownChainSpecFromJson;
-declare const index$h_loadConfig: typeof loadConfig;
-declare const index$h_parseBootnode: typeof parseBootnode;
-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_knownChainSpecFromJson as knownChainSpecFromJson,
-    index$h_loadConfig as loadConfig,
-    logger$2 as logger,
-    index$h_parseBootnode as parseBootnode,
-  };
+    throw new Error(`Unable to parse config: ${e}`);
+  }
+}
+
+declare function deepMerge(target: AnyJsonObject, source: JsonValue): void {
+  if (!isJsonObject(source)) {
+    throw new Error(`Expected object, got ${source}`);
+  }
+  for (const key in source) {
+    if (isJsonObject(source[key])) {
+      if (!isJsonObject(target[key])) {
+        target[key] = {};
+      }
+      deepMerge(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+}
+
+/**
+ * Caution: updates input directly.
+ * Processes a pseudo-jq query. Syntax:
+ * .path.to.value = { ... } - updates value with the specified object by replacement
+ * .path.to.value += { ... } - updates value with the specified object by merging
+ * .path.to.value = file.json - updates value with the contents of file.json
+ * .path.to.value += file.json - merges the contents of file.json onto value
+ */
+declare function processQuery(input: AnyJsonObject, query: string, withRelPath: (p: string) => string): void {
+  const queryParts = query.split("=");
+
+  if (queryParts.length === 2) {
+    let [path, value] = queryParts.map((part) => part.trim());
+    let merge = false;
+
+    // detect += syntax
+    if (path.endsWith("+")) {
+      merge = true;
+      path = path.slice(0, -1);
+    }
+
+    let parsedValue: JsonValue;
+    if (value.endsWith(".json")) {
+      try {
+        const configFile = fs.readFileSync(withRelPath(value), "utf8");
+        const parsed = JSON.parse(configFile);
+        parsedValue = parsed;
+      } catch (e) {
+        throw new Error(`Unable to load config from ${value}: ${e}`);
+      }
+    } else {
+      try {
+        parsedValue = JSON.parse(value);
+      } catch (e) {
+        throw new Error(`Unrecognized syntax '${value}': ${e}`);
+      }
+    }
+
+    let pathParts = path.split(".");
+
+    // allow leading dot in path
+    if (pathParts[0] === "") {
+      pathParts = pathParts.slice(1);
+    }
+
+    let target = input;
+    for (let i = 0; i < pathParts.length; i++) {
+      const part = pathParts[i];
+      if (!isJsonObject(target[part])) {
+        target[part] = {};
+      }
+      if (i === pathParts.length - 1) {
+        if (merge) {
+          deepMerge(target[part], parsedValue);
+        } else {
+          target[part] = parsedValue;
+        }
+        return;
+      }
+      target = target[part];
+    }
+  }
+
+  throw new Error("Unrecognized syntax.");
+}
+
+type JsonValue = string | number | boolean | null | AnyJsonObject | JsonArray;
+
+interface AnyJsonObject {
+  [key: string]: JsonValue;
+}
+
+interface JsonArray extends Array<JsonValue> {}
+
+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 };
 }
 
 /**
@@ -9057,43 +9185,43 @@ declare const bitLookup = [
   [0b00000000, 8],
 ];
 
-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 };
+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 };
 }
 
 /**
@@ -9160,7 +9288,7 @@ declare function accumulationOutputComparator(a: AccumulationOutput, b: Accumula
     return Ordering.Greater;
   }
 
-  return Ordering.Equal;
+  return a.output.compare(b.output);
 }
 
 /**
@@ -9523,16 +9651,16 @@ declare class Mountain<H extends OpaqueHash> {
   }
 }
 
-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 };
+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 };
 }
 
 /**
@@ -9992,25 +10120,6 @@ declare class LookupHistoryItem {
   }
 }
 
-/** Dictionary entry of services that auto-accumulate every block. */
-declare class AutoAccumulate {
-  static Codec = codec.Class(AutoAccumulate, {
-    service: codec.u32.asOpaque<ServiceId>(),
-    gasLimit: codec.u64.asOpaque<ServiceGas>(),
-  });
-
-  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
-    return new AutoAccumulate(service, gasLimit);
-  }
-
-  private constructor(
-    /** Service id that auto-accumulates. */
-    readonly service: ServiceId,
-    /** Gas limit for auto-accumulation. */
-    readonly gasLimit: ServiceGas,
-  ) {}
-}
-
 /**
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
  */
@@ -10023,7 +10132,9 @@ declare class PrivilegedServices {
     registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
       ? codec.u32.asOpaque<ServiceId>()
       : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-    autoAccumulateServices: readonlyArray(codec.sequenceVarLen(AutoAccumulate.Codec)),
+    autoAccumulateServices: codec.dictionary(codec.u32.asOpaque<ServiceId>(), codec.u64.asOpaque<ServiceGas>(), {
+      sortKeys: (a, b) => a - b,
+    }),
   });
 
   static create(a: CodecRecord<PrivilegedServices>) {
@@ -10048,7 +10159,7 @@ declare class PrivilegedServices {
     /** `χ_A`: Manages authorization queue one for each core. */
     readonly assigners: PerCore<ServiceId>,
     /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
-    readonly autoAccumulateServices: readonly AutoAccumulate[],
+    readonly autoAccumulateServices: Map<ServiceId, ServiceGas>,
   ) {}
 }
 
@@ -10912,6 +11023,18 @@ declare class InMemoryService extends WithDebug implements Service {
     };
   }
 
+  /** Return identical `InMemoryService` which does not share any references. */
+  clone(): InMemoryService {
+    return new InMemoryService(this.serviceId, {
+      info: ServiceAccountInfo.create(this.data.info),
+      preimages: HashDictionary.fromEntries(Array.from(this.data.preimages.entries())),
+      lookupHistory: HashDictionary.fromEntries(
+        Array.from(this.data.lookupHistory.entries()).map(([k, v]) => [k, v.slice()]),
+      ),
+      storage: new Map(this.data.storage.entries()),
+    });
+  }
+
   /**
    * Create a new in-memory service from another state service
    * by copying all given entries.
@@ -11365,7 +11488,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
         assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
         delegator: tryAsServiceId(0),
         registrar: tryAsServiceId(MAX_VALUE),
-        autoAccumulateServices: [],
+        autoAccumulateServices: new Map(),
       }),
       accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
       services: new Map(),
@@ -11414,125 +11537,123 @@ type FieldNames<T> = {
   [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-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_AutoAccumulate = AutoAccumulate;
-declare const index$e_AutoAccumulate: typeof AutoAccumulate;
-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_AutoAccumulate as AutoAccumulate, 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 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 StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -12001,7 +12122,6 @@ declare function* serializeRemovedServices(servicesRemoved: ServiceId[] | undefi
     return;
   }
   for (const serviceId of servicesRemoved) {
-    // TODO [ToDr] what about all data associated with a service?
     const codec = serialize.serviceData(serviceId);
     yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
   }
@@ -12632,47 +12752,47 @@ declare function loadState(spec: ChainSpec, blake2b: Blake2b, entries: Iterable<
  *        hashmap of `key -> value` entries.
  */
 
-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 };
+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 };
 }
 
 /** Error during `LeafDb` creation. */
@@ -13024,31 +13144,31 @@ declare class InMemorySerializedStates implements StatesDb<SerializedState<LeafD
   async close() {}
 }
 
-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 };
+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 };
 }
 
 /**
@@ -13470,31 +13590,31 @@ declare const initEc = async () => {
   await init.reedSolomon();
 };
 
-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 };
+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 };
 }
 
 /** A per-client handler of incoming socket messages. */
@@ -13997,45 +14117,45 @@ declare class FuzzTarget implements IpcHandler {
   }
 }
 
-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$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$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 };
+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 };
 }
 
 /** Size of the transfer memo. */
@@ -14136,13 +14256,6 @@ declare enum ForgetPreimageError {
 
 /**
  * Errors that may occur when the transfer is invoked.
- *
- * TODO [ToDr] Since I don't fully understand yet which of these
- * could be checked directly in the host call (i.e. if we will
- * have access to the service account state there) for now I keep
- * them safely in the `AccumulationPartialState` implementation.
- * However, if possible, these should be moved directly to the
- * host call implementation.
  */
 declare enum TransferError {
   /** The destination service does not exist. */
@@ -14307,7 +14420,7 @@ interface PartialState {
     a: PerCore<ServiceId>,
     v: ServiceId | null,
     r: ServiceId | null,
-    z: [ServiceId, ServiceGas][],
+    z: Map<ServiceId, ServiceGas>,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /** Yield accumulation trie result hash. */
@@ -15327,25 +15440,25 @@ declare function getRegisters(argsLength: number) {
   return regs;
 }
 
-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 {
+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 {
   export {
-    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,
+    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,
   };
 }
 
@@ -15403,13 +15516,13 @@ declare function extractCodeAndMetadata(blobWithMetadata: Uint8Array) {
   return { metadata, code };
 }
 
-type index$7_Program = Program;
-declare const index$7_Program: typeof Program;
-declare const index$7_extractCodeAndMetadata: typeof extractCodeAndMetadata;
-declare namespace index$7 {
+type index$8_Program = Program;
+declare const index$8_Program: typeof Program;
+declare const index$8_extractCodeAndMetadata: typeof extractCodeAndMetadata;
+declare namespace index$8 {
   export {
-    index$7_Program as Program,
-    index$7_extractCodeAndMetadata as extractCodeAndMetadata,
+    index$8_Program as Program,
+    index$8_extractCodeAndMetadata as extractCodeAndMetadata,
   };
 }
 
@@ -18462,24 +18575,24 @@ declare class Interpreter implements IPvmInterpreter {
   }
 }
 
-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_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 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 };
 }
 
 type ResolveFn = (pvm: IPvmInterpreter) => void;
@@ -18665,18 +18778,18 @@ declare class HostCalls {
   }
 }
 
-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 };
+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 };
 }
 
 /**
@@ -18873,7 +18986,7 @@ declare class AccumulationStateUpdate {
     /** Pending transfers. */
     public transfers: PendingTransfer[],
     /** Yielded accumulation root. */
-    public readonly yieldedRoots: Map<ServiceId, OpaqueHash> = new Map(),
+    public yieldedRoot: OpaqueHash | null = null,
   ) {}
 
   /** Create new empty state update. */
@@ -18912,7 +19025,7 @@ declare class AccumulationStateUpdate {
       storage: deepCloneMapWithArray(from.services.storage),
     };
     const transfers = [...from.transfers];
-    const update = new AccumulationStateUpdate(serviceUpdates, transfers, new Map(from.yieldedRoots));
+    const update = new AccumulationStateUpdate(serviceUpdates, transfers, from.yieldedRoot);
 
     // update entries
     for (const [k, v] of from.authorizationQueues) {
@@ -18938,6 +19051,13 @@ declare class AccumulationStateUpdate {
     this.transfers = [];
     return transfers;
   }
+
+  /** Retrieve and clear yielded root. */
+  takeYieldedRoot() {
+    const yieldedRoot = this.yieldedRoot;
+    this.yieldedRoot = null;
+    return yieldedRoot;
+  }
 }
 
 type StateSlice = Pick<State, "getService" | "privilegedServices">;
@@ -19038,6 +19158,21 @@ declare class PartiallyUpdatedState<T extends StateSlice = StateSlice> {
     hash: PreimageHash,
     length: U64,
   ): LookupHistoryItem | null {
+    const updatedService = this.stateUpdate.services.updated.get(serviceId);
+
+    /** Return lookup history item for newly created service */
+    if (updatedService !== undefined && updatedService.action.kind === UpdateServiceKind.Create) {
+      const lookupHistoryItem = updatedService.action.lookupHistory;
+
+      if (
+        lookupHistoryItem !== null &&
+        hash.isEqualTo(lookupHistoryItem.hash) &&
+        length === BigInt(lookupHistoryItem.length)
+      ) {
+        return lookupHistoryItem;
+      }
+    }
+
     const preimages = this.stateUpdate.services.preimages.get(serviceId) ?? [];
     // TODO [ToDr] This is most likely wrong. We may have `provide` and `remove` within
     // the same state update. We should however switch to proper "updated state"
@@ -19270,71 +19405,95 @@ declare function emptyRegistersBuffer(): Uint8Array {
   return safeAllocUint8Array(NO_OF_REGISTERS * REGISTER_BYTE_SIZE);
 }
 
-type index$4_AccumulationStateUpdate = AccumulationStateUpdate;
-declare const index$4_AccumulationStateUpdate: typeof AccumulationStateUpdate;
-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_ForgetPreimageError = ForgetPreimageError;
-declare const index$4_ForgetPreimageError: typeof ForgetPreimageError;
-declare const index$4_HostCallResult: typeof HostCallResult;
-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;
-type index$4_MachineId = MachineId;
-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_MemoryOperation = MemoryOperation;
-declare const index$4_MemoryOperation: typeof MemoryOperation;
-type index$4_NewServiceError = NewServiceError;
-declare const index$4_NewServiceError: typeof NewServiceError;
-type index$4_NoMachineError = NoMachineError;
-type index$4_PagesError = PagesError;
-declare const index$4_PagesError: typeof PagesError;
-type index$4_PartialState = PartialState;
-type index$4_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
-declare const index$4_PartiallyUpdatedState: typeof PartiallyUpdatedState;
-type index$4_PeekPokeError = PeekPokeError;
-declare const index$4_PeekPokeError: typeof PeekPokeError;
-type index$4_PendingTransfer = PendingTransfer;
-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_ProgramCounter = ProgramCounter;
-type index$4_ProvidePreimageError = ProvidePreimageError;
-declare const index$4_ProvidePreimageError: typeof ProvidePreimageError;
-type index$4_RefineExternalities = RefineExternalities;
-type index$4_RequestPreimageError = RequestPreimageError;
-declare const index$4_RequestPreimageError: typeof RequestPreimageError;
-declare const index$4_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
-type index$4_SegmentExportError = SegmentExportError;
-type index$4_ServiceStateUpdate = ServiceStateUpdate;
-type index$4_StateSlice = StateSlice;
-type index$4_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
-type index$4_TransferError = TransferError;
-declare const index$4_TransferError: typeof TransferError;
-type index$4_UnprivilegedError = UnprivilegedError;
-type index$4_UpdatePrivilegesError = UpdatePrivilegesError;
-declare const index$4_UpdatePrivilegesError: typeof UpdatePrivilegesError;
-type index$4_ZeroVoidError = ZeroVoidError;
-declare const index$4_ZeroVoidError: typeof ZeroVoidError;
-declare const index$4_clampU64ToU32: typeof clampU64ToU32;
-declare const index$4_deepCloneMapWithArray: typeof deepCloneMapWithArray;
-declare const index$4_emptyRegistersBuffer: typeof emptyRegistersBuffer;
-declare const index$4_getServiceId: typeof getServiceId;
-declare const index$4_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
-declare const index$4_preimageLenAsU32: typeof preimageLenAsU32;
-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_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, 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 };
+/**
+ * Service account details with threshold balance.
+ *
+ * Used exclusively by `info` host call.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/33920033b500?v=0.7.2
+ */
+declare const codecServiceAccountInfoWithThresholdBalance = codec.object(
+  {
+    codeHash: codec.bytes(HASH_SIZE),
+    balance: codec.u64,
+    thresholdBalance: codec.u64,
+    accumulateMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
+    onTransferMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
+    storageUtilisationBytes: codec.u64,
+    storageUtilisationCount: codec.u32,
+    gratisStorage: codec.u64,
+    created: codec.u32.convert((x) => x, tryAsTimeSlot),
+    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
+    parentService: codec.u32.convert((x) => x, tryAsServiceId),
+  },
+  "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 {
@@ -19344,11 +19503,6 @@ declare class DebuggerAdapter {
     this.pvm = new Interpreter({ useSbrkGas });
   }
 
-  // TODO [MaSi]: a temporary solution that is needed to implement host calls in PVM debugger
-  getInterpreter() {
-    return this.pvm;
-  }
-
   resetGeneric(rawProgram: Uint8Array, flatRegisters: Uint8Array, initialGas: bigint) {
     this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
   }
@@ -19428,132 +19582,133 @@ declare class DebuggerAdapter {
   }
 }
 
-type index$3_AccumulationStateUpdate = AccumulationStateUpdate;
-declare const index$3_AccumulationStateUpdate: typeof AccumulationStateUpdate;
-type index$3_Args = Args;
-type index$3_ArgsDecoder = ArgsDecoder;
-declare const index$3_ArgsDecoder: typeof ArgsDecoder;
-type index$3_ArgumentType = ArgumentType;
-declare const index$3_ArgumentType: typeof ArgumentType;
-type index$3_BasicBlocks = BasicBlocks;
-declare const index$3_BasicBlocks: typeof BasicBlocks;
-declare const index$3_CURRENT_SERVICE_ID: typeof CURRENT_SERVICE_ID;
-type index$3_EjectError = EjectError;
-declare const index$3_EjectError: typeof EjectError;
-type index$3_EnumMapping = EnumMapping;
-type index$3_ErrorResult<Error> = ErrorResult<Error>;
-type index$3_ExtendedWitdthImmediateDecoder = ExtendedWitdthImmediateDecoder;
-declare const index$3_ExtendedWitdthImmediateDecoder: typeof ExtendedWitdthImmediateDecoder;
-type index$3_ForgetPreimageError = ForgetPreimageError;
-declare const index$3_ForgetPreimageError: typeof ForgetPreimageError;
-type index$3_HostCallMemory = HostCallMemory;
-declare const index$3_HostCallMemory: typeof HostCallMemory;
-type index$3_HostCallRegisters = HostCallRegisters;
-declare const index$3_HostCallRegisters: typeof HostCallRegisters;
-declare const index$3_HostCallResult: typeof HostCallResult;
-type index$3_ImmediateDecoder = ImmediateDecoder;
-declare const index$3_ImmediateDecoder: typeof ImmediateDecoder;
-type index$3_InsufficientFundsError = InsufficientFundsError;
-declare const index$3_MAX_U32: typeof MAX_U32;
-declare const index$3_MAX_U32_BIG_INT: typeof MAX_U32_BIG_INT;
-type index$3_MachineId = MachineId;
-type index$3_MachineInstance = MachineInstance;
-declare const index$3_MachineInstance: typeof MachineInstance;
-type index$3_MachineResult = MachineResult;
-type index$3_MachineStatus = MachineStatus;
-type index$3_Mask = Mask;
-declare const index$3_Mask: typeof Mask;
-type index$3_MemoryOperation = MemoryOperation;
-declare const index$3_MemoryOperation: typeof MemoryOperation;
-type index$3_MemorySegment = MemorySegment;
-declare const index$3_MemorySegment: typeof MemorySegment;
-type index$3_NewServiceError = NewServiceError;
-declare const index$3_NewServiceError: typeof NewServiceError;
-type index$3_NibblesDecoder = NibblesDecoder;
-declare const index$3_NibblesDecoder: typeof NibblesDecoder;
-type index$3_NoMachineError = NoMachineError;
-type index$3_OK = OK;
-type index$3_OkResult<Ok> = OkResult<Ok>;
-type index$3_Opaque<Type, Token extends string> = Opaque<Type, Token>;
-type index$3_PagesError = PagesError;
-declare const index$3_PagesError: typeof PagesError;
-type index$3_PartialState = PartialState;
-type index$3_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
-declare const index$3_PartiallyUpdatedState: typeof PartiallyUpdatedState;
-type index$3_PeekPokeError = PeekPokeError;
-declare const index$3_PeekPokeError: typeof PeekPokeError;
-type index$3_PendingTransfer = PendingTransfer;
-declare const index$3_PendingTransfer: typeof PendingTransfer;
-type index$3_PreimageStatus = PreimageStatus;
-type index$3_PreimageStatusKind = PreimageStatusKind;
-declare const index$3_PreimageStatusKind: typeof PreimageStatusKind;
-type index$3_Program = Program;
-declare const index$3_Program: typeof Program;
-type index$3_ProgramCounter = ProgramCounter;
-type index$3_ProgramDecoder = ProgramDecoder;
-declare const index$3_ProgramDecoder: typeof ProgramDecoder;
-type index$3_ProvidePreimageError = ProvidePreimageError;
-declare const index$3_ProvidePreimageError: typeof ProvidePreimageError;
-type index$3_RefineExternalities = RefineExternalities;
-type index$3_Registers = Registers;
-declare const index$3_Registers: typeof Registers;
-type index$3_RequestPreimageError = RequestPreimageError;
-declare const index$3_RequestPreimageError: typeof RequestPreimageError;
-type index$3_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
-declare const index$3_RichTaggedError: typeof RichTaggedError;
-declare const index$3_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
-type index$3_SegmentExportError = SegmentExportError;
-type index$3_ServiceStateUpdate = ServiceStateUpdate;
-type index$3_SpiMemory = SpiMemory;
-declare const index$3_SpiMemory: typeof SpiMemory;
-type index$3_SpiProgram = SpiProgram;
-declare const index$3_SpiProgram: typeof SpiProgram;
-type index$3_StateSlice = StateSlice;
-type index$3_StringLiteral<Type> = StringLiteral<Type>;
-type index$3_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
-type index$3_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
-type index$3_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
-type index$3_TransferError = TransferError;
-declare const index$3_TransferError: typeof TransferError;
-type index$3_Uninstantiable = Uninstantiable;
-type index$3_UnprivilegedError = UnprivilegedError;
-type index$3_UpdatePrivilegesError = UpdatePrivilegesError;
-declare const index$3_UpdatePrivilegesError: typeof UpdatePrivilegesError;
-type index$3_WithDebug = WithDebug;
-declare const index$3_WithDebug: typeof WithDebug;
-type index$3_WithOpaque<Token extends string> = WithOpaque<Token>;
-type index$3_ZeroVoidError = ZeroVoidError;
-declare const index$3_ZeroVoidError: typeof ZeroVoidError;
-declare const index$3___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
-declare const index$3_asOpaqueType: typeof asOpaqueType;
-declare const index$3_assertEmpty: typeof assertEmpty;
-declare const index$3_assertNever: typeof assertNever;
-declare const index$3_check: typeof check;
-declare const index$3_clampU64ToU32: typeof clampU64ToU32;
-declare const index$3_createResults: typeof createResults;
-declare const index$3_decodeStandardProgram: typeof decodeStandardProgram;
-declare const index$3_deepCloneMapWithArray: typeof deepCloneMapWithArray;
-declare const index$3_emptyRegistersBuffer: typeof emptyRegistersBuffer;
-declare const index$3_extractCodeAndMetadata: typeof extractCodeAndMetadata;
-declare const index$3_getServiceId: typeof getServiceId;
-declare const index$3_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
-declare const index$3_inspect: typeof inspect;
-declare const index$3_instructionArgumentTypeMap: typeof instructionArgumentTypeMap;
-declare const index$3_isBrowser: typeof isBrowser;
-declare const index$3_isTaggedError: typeof isTaggedError;
-declare const index$3_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
-declare const index$3_measure: typeof measure;
-declare const index$3_preimageLenAsU32: typeof preimageLenAsU32;
-declare const index$3_resultToString: typeof resultToString;
-declare const index$3_seeThrough: typeof seeThrough;
-declare const index$3_slotsToPreimageStatus: typeof slotsToPreimageStatus;
-declare const index$3_toMemoryOperation: typeof toMemoryOperation;
-declare const index$3_tryAsMachineId: typeof tryAsMachineId;
-declare const index$3_tryAsProgramCounter: typeof tryAsProgramCounter;
-declare const index$3_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
-declare namespace index$3 {
-  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$l as block, index$s as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_deepCloneMapWithArray as deepCloneMapWithArray, index$3_emptyRegistersBuffer as emptyRegistersBuffer, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$p as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$6 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$r as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
-  export type { index$3_Args as Args, index$3_EnumMapping as EnumMapping, index$3_ErrorResult as ErrorResult, index$3_InsufficientFundsError as InsufficientFundsError, index$3_MachineId as MachineId, index$3_MachineResult as MachineResult, index$3_MachineStatus as MachineStatus, index$3_NoMachineError as NoMachineError, index$3_OK as OK, index$3_OkResult as OkResult, index$3_Opaque as Opaque, index$3_PartialState as PartialState, index$3_PreimageStatus as PreimageStatus, index$3_ProgramCounter as ProgramCounter, index$3_RefineExternalities as RefineExternalities, index$3_SegmentExportError as SegmentExportError, index$3_ServiceStateUpdate as ServiceStateUpdate, index$3_StateSlice as StateSlice, index$3_StringLiteral as StringLiteral, index$3_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$3_TaggedError as TaggedError, index$3_TokenOf as TokenOf, index$3_Uninstantiable as Uninstantiable, index$3_UnprivilegedError as UnprivilegedError, index$3_WithOpaque as WithOpaque };
+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;
+type index$4_MachineId = MachineId;
+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;
+type index$4_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
+declare const index$4_PartiallyUpdatedState: typeof PartiallyUpdatedState;
+type index$4_PeekPokeError = PeekPokeError;
+declare const index$4_PeekPokeError: typeof PeekPokeError;
+type index$4_PendingTransfer = PendingTransfer;
+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 };
 }
 
 declare const ENTROPY_BYTES = 32;
@@ -19583,10 +19738,10 @@ declare function fisherYatesShuffle<T>(blake2b: Blake2b, arr: T[], entropy: Byte
   return result;
 }
 
-declare const index$2_fisherYatesShuffle: typeof fisherYatesShuffle;
-declare namespace index$2 {
+declare const index$3_fisherYatesShuffle: typeof fisherYatesShuffle;
+declare namespace index$3 {
   export {
-    index$2_fisherYatesShuffle as fisherYatesShuffle,
+    index$3_fisherYatesShuffle as fisherYatesShuffle,
   };
 }
 
@@ -20146,10 +20301,10 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
         chi_v: "number",
         chi_r: json.optional("number"),
         chi_g: json.nullable(
-          json.array({
-            service: "number",
-            gasLimit: json.fromNumber((v) => tryAsServiceGas(v)),
-          }),
+          json.map(
+            "number",
+            json.fromNumber((v) => tryAsServiceGas(v)),
+          ),
         ),
       },
       pi: JsonStatisticsData.fromJson,
@@ -20216,7 +20371,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
           assigners: chi.chi_a,
           delegator: chi.chi_v,
           registrar: chi.chi_r ?? tryAsServiceId(2 ** 32 - 1),
-          autoAccumulateServices: chi.chi_g ?? [],
+          autoAccumulateServices: chi.chi_g ?? new Map(),
         }),
         statistics: JsonStatisticsData.toStatisticsData(spec, pi),
         accumulationQueue: omega,
@@ -20230,49 +20385,128 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
     },
   );
 
-type index$1_JsonAvailabilityAssignment = JsonAvailabilityAssignment;
-type index$1_JsonCoreStatistics = JsonCoreStatistics;
-declare const index$1_JsonCoreStatistics: typeof JsonCoreStatistics;
-type index$1_JsonDisputesRecords = JsonDisputesRecords;
-declare const index$1_JsonDisputesRecords: typeof JsonDisputesRecords;
-type index$1_JsonLookupMeta = JsonLookupMeta;
-type index$1_JsonPreimageItem = JsonPreimageItem;
-declare const index$1_JsonPreimageItem: typeof JsonPreimageItem;
-type index$1_JsonPreimageStatus = JsonPreimageStatus;
-type index$1_JsonRecentBlockState = JsonRecentBlockState;
-type index$1_JsonRecentBlocks = JsonRecentBlocks;
-type index$1_JsonReportedWorkPackageInfo = JsonReportedWorkPackageInfo;
-type index$1_JsonService = JsonService;
-declare const index$1_JsonService: typeof JsonService;
-type index$1_JsonServiceInfo = JsonServiceInfo;
-declare const index$1_JsonServiceInfo: typeof JsonServiceInfo;
-type index$1_JsonServiceStatistics = JsonServiceStatistics;
-declare const index$1_JsonServiceStatistics: typeof JsonServiceStatistics;
-type index$1_JsonStateDump = JsonStateDump;
-type index$1_JsonStatisticsData = JsonStatisticsData;
-declare const index$1_JsonStatisticsData: typeof JsonStatisticsData;
-type index$1_JsonStorageItem = JsonStorageItem;
-declare const index$1_JsonStorageItem: typeof JsonStorageItem;
-type index$1_JsonValidatorStatistics = JsonValidatorStatistics;
-declare const index$1_JsonValidatorStatistics: typeof JsonValidatorStatistics;
-type index$1_ServiceStatisticsEntry = ServiceStatisticsEntry;
-type index$1_TicketsOrKeys = TicketsOrKeys;
-declare const index$1_TicketsOrKeys: typeof TicketsOrKeys;
-declare const index$1_availabilityAssignmentFromJson: typeof availabilityAssignmentFromJson;
-declare const index$1_disputesRecordsFromJson: typeof disputesRecordsFromJson;
-declare const index$1_fullStateDumpFromJson: typeof fullStateDumpFromJson;
-declare const index$1_lookupMetaFromJson: typeof lookupMetaFromJson;
-declare const index$1_notYetAccumulatedFromJson: typeof notYetAccumulatedFromJson;
-declare const index$1_preimageStatusFromJson: typeof preimageStatusFromJson;
-declare const index$1_recentBlockStateFromJson: typeof recentBlockStateFromJson;
-declare const index$1_recentBlocksHistoryFromJson: typeof recentBlocksHistoryFromJson;
-declare const index$1_reportedWorkPackageFromJson: typeof reportedWorkPackageFromJson;
-declare const index$1_serviceStatisticsEntryFromJson: typeof serviceStatisticsEntryFromJson;
-declare const index$1_ticketFromJson: typeof ticketFromJson;
-declare const index$1_validatorDataFromJson: typeof validatorDataFromJson;
+type index$2_JsonAvailabilityAssignment = JsonAvailabilityAssignment;
+type index$2_JsonCoreStatistics = JsonCoreStatistics;
+declare const index$2_JsonCoreStatistics: typeof JsonCoreStatistics;
+type index$2_JsonDisputesRecords = JsonDisputesRecords;
+declare const index$2_JsonDisputesRecords: typeof JsonDisputesRecords;
+type index$2_JsonLookupMeta = JsonLookupMeta;
+type index$2_JsonPreimageItem = JsonPreimageItem;
+declare const index$2_JsonPreimageItem: typeof JsonPreimageItem;
+type index$2_JsonPreimageStatus = JsonPreimageStatus;
+type index$2_JsonRecentBlockState = JsonRecentBlockState;
+type index$2_JsonRecentBlocks = JsonRecentBlocks;
+type index$2_JsonReportedWorkPackageInfo = JsonReportedWorkPackageInfo;
+type index$2_JsonService = JsonService;
+declare const index$2_JsonService: typeof JsonService;
+type index$2_JsonServiceInfo = JsonServiceInfo;
+declare const index$2_JsonServiceInfo: typeof JsonServiceInfo;
+type index$2_JsonServiceStatistics = JsonServiceStatistics;
+declare const index$2_JsonServiceStatistics: typeof JsonServiceStatistics;
+type index$2_JsonStateDump = JsonStateDump;
+type index$2_JsonStatisticsData = JsonStatisticsData;
+declare const index$2_JsonStatisticsData: typeof JsonStatisticsData;
+type index$2_JsonStorageItem = JsonStorageItem;
+declare const index$2_JsonStorageItem: typeof JsonStorageItem;
+type index$2_JsonValidatorStatistics = JsonValidatorStatistics;
+declare const index$2_JsonValidatorStatistics: typeof JsonValidatorStatistics;
+type index$2_ServiceStatisticsEntry = ServiceStatisticsEntry;
+type index$2_TicketsOrKeys = TicketsOrKeys;
+declare const index$2_TicketsOrKeys: typeof TicketsOrKeys;
+declare const index$2_availabilityAssignmentFromJson: typeof availabilityAssignmentFromJson;
+declare const index$2_disputesRecordsFromJson: typeof disputesRecordsFromJson;
+declare const index$2_fullStateDumpFromJson: typeof fullStateDumpFromJson;
+declare const index$2_lookupMetaFromJson: typeof lookupMetaFromJson;
+declare const index$2_notYetAccumulatedFromJson: typeof notYetAccumulatedFromJson;
+declare const index$2_preimageStatusFromJson: typeof preimageStatusFromJson;
+declare const index$2_recentBlockStateFromJson: typeof recentBlockStateFromJson;
+declare const index$2_recentBlocksHistoryFromJson: typeof recentBlocksHistoryFromJson;
+declare const index$2_reportedWorkPackageFromJson: typeof reportedWorkPackageFromJson;
+declare const index$2_serviceStatisticsEntryFromJson: typeof serviceStatisticsEntryFromJson;
+declare const index$2_ticketFromJson: typeof ticketFromJson;
+declare const index$2_validatorDataFromJson: typeof validatorDataFromJson;
+declare namespace index$2 {
+  export { index$2_JsonCoreStatistics as JsonCoreStatistics, index$2_JsonDisputesRecords as JsonDisputesRecords, index$2_JsonPreimageItem as JsonPreimageItem, index$2_JsonService as JsonService, index$2_JsonServiceInfo as JsonServiceInfo, index$2_JsonServiceStatistics as JsonServiceStatistics, index$2_JsonStatisticsData as JsonStatisticsData, index$2_JsonStorageItem as JsonStorageItem, index$2_JsonValidatorStatistics as JsonValidatorStatistics, index$2_TicketsOrKeys as TicketsOrKeys, index$2_availabilityAssignmentFromJson as availabilityAssignmentFromJson, index$2_disputesRecordsFromJson as disputesRecordsFromJson, index$2_fullStateDumpFromJson as fullStateDumpFromJson, index$2_lookupMetaFromJson as lookupMetaFromJson, index$2_notYetAccumulatedFromJson as notYetAccumulatedFromJson, index$2_preimageStatusFromJson as preimageStatusFromJson, index$2_recentBlockStateFromJson as recentBlockStateFromJson, index$2_recentBlocksHistoryFromJson as recentBlocksHistoryFromJson, index$2_reportedWorkPackageFromJson as reportedWorkPackageFromJson, index$2_serviceStatisticsEntryFromJson as serviceStatisticsEntryFromJson, index$2_ticketFromJson as ticketFromJson, index$2_validatorDataFromJson as validatorDataFromJson };
+  export type { index$2_JsonAvailabilityAssignment as JsonAvailabilityAssignment, index$2_JsonLookupMeta as JsonLookupMeta, index$2_JsonPreimageStatus as JsonPreimageStatus, index$2_JsonRecentBlockState as JsonRecentBlockState, index$2_JsonRecentBlocks as JsonRecentBlocks, index$2_JsonReportedWorkPackageInfo as JsonReportedWorkPackageInfo, index$2_JsonStateDump as JsonStateDump, index$2_ServiceStatisticsEntry as ServiceStatisticsEntry };
+}
+
+declare class StateKeyVal {
+  static fromJson: FromJson<StateKeyVal> = {
+    key: fromJson.bytesN(TRUNCATED_HASH_SIZE),
+    value: fromJson.bytesBlob,
+  };
+  key!: TruncatedHash;
+  value!: BytesBlob;
+}
+
+declare class TestState {
+  static fromJson: FromJson<TestState> = {
+    state_root: fromJson.bytes32(),
+    keyvals: json.array(StateKeyVal.fromJson),
+  };
+
+  static Codec = codec.object({
+    state_root: codec.bytes(HASH_SIZE).asOpaque<StateRootHash>(),
+    keyvals: codec.sequenceVarLen(
+      codec.object({
+        key: codec.bytes(TRUNCATED_HASH_SIZE),
+        value: codec.blob,
+      }),
+    ),
+  });
+
+  state_root!: StateRootHash;
+  keyvals!: StateKeyVal[];
+}
+
+declare class StateTransitionGenesis {
+  static fromJson: FromJson<StateTransitionGenesis> = {
+    header: headerFromJson,
+    state: TestState.fromJson,
+  };
+
+  static Codec = codec.object({
+    header: Header.Codec,
+    state: TestState.Codec,
+  });
+
+  header!: Header;
+  state!: TestState;
+}
+
+declare class StateTransition {
+  static fromJson: FromJson<StateTransition> = {
+    pre_state: TestState.fromJson,
+    post_state: TestState.fromJson,
+    block: blockFromJson(tinyChainSpec),
+  };
+
+  static Codec = codec.object({
+    pre_state: TestState.Codec,
+    block: Block.Codec,
+    post_state: TestState.Codec,
+  });
+
+  pre_state!: TestState;
+  post_state!: TestState;
+  block!: Block;
+}
+
+type index$1_StateKeyVal = StateKeyVal;
+declare const index$1_StateKeyVal: typeof StateKeyVal;
+type index$1_StateTransition = StateTransition;
+declare const index$1_StateTransition: typeof StateTransition;
+type index$1_StateTransitionGenesis = StateTransitionGenesis;
+declare const index$1_StateTransitionGenesis: typeof StateTransitionGenesis;
+type index$1_TestState = TestState;
+declare const index$1_TestState: typeof TestState;
 declare namespace index$1 {
-  export { index$1_JsonCoreStatistics as JsonCoreStatistics, index$1_JsonDisputesRecords as JsonDisputesRecords, index$1_JsonPreimageItem as JsonPreimageItem, index$1_JsonService as JsonService, index$1_JsonServiceInfo as JsonServiceInfo, index$1_JsonServiceStatistics as JsonServiceStatistics, index$1_JsonStatisticsData as JsonStatisticsData, index$1_JsonStorageItem as JsonStorageItem, index$1_JsonValidatorStatistics as JsonValidatorStatistics, index$1_TicketsOrKeys as TicketsOrKeys, index$1_availabilityAssignmentFromJson as availabilityAssignmentFromJson, index$1_disputesRecordsFromJson as disputesRecordsFromJson, index$1_fullStateDumpFromJson as fullStateDumpFromJson, index$1_lookupMetaFromJson as lookupMetaFromJson, index$1_notYetAccumulatedFromJson as notYetAccumulatedFromJson, index$1_preimageStatusFromJson as preimageStatusFromJson, index$1_recentBlockStateFromJson as recentBlockStateFromJson, index$1_recentBlocksHistoryFromJson as recentBlocksHistoryFromJson, index$1_reportedWorkPackageFromJson as reportedWorkPackageFromJson, index$1_serviceStatisticsEntryFromJson as serviceStatisticsEntryFromJson, index$1_ticketFromJson as ticketFromJson, index$1_validatorDataFromJson as validatorDataFromJson };
-  export type { index$1_JsonAvailabilityAssignment as JsonAvailabilityAssignment, index$1_JsonLookupMeta as JsonLookupMeta, index$1_JsonPreimageStatus as JsonPreimageStatus, index$1_JsonRecentBlockState as JsonRecentBlockState, index$1_JsonRecentBlocks as JsonRecentBlocks, index$1_JsonReportedWorkPackageInfo as JsonReportedWorkPackageInfo, index$1_JsonStateDump as JsonStateDump, index$1_ServiceStatisticsEntry as ServiceStatisticsEntry };
+  export {
+    index$1_StateKeyVal as StateKeyVal,
+    index$1_StateTransition as StateTransition,
+    index$1_StateTransitionGenesis as StateTransitionGenesis,
+    index$1_TestState as TestState,
+  };
 }
 
 /** Helper function to create most used hashes in the block */
@@ -20330,17 +20564,6 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
 
     return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), extrinsicView, encoded);
   }
-
-  /** Creates hash for given WorkPackage */
-  workPackage(workPackage: WorkPackage): WithHashAndBytes<WorkPackageHash, WorkPackage> {
-    return this.encode(WorkPackage.Codec, workPackage);
-  }
-
-  private encode<T, THash extends OpaqueHash>(codec: Codec<T>, data: T): WithHashAndBytes<THash, T> {
-    // TODO [ToDr] Use already allocated encoding destination and hash bytes from some arena.
-    const encoded = Encoder.encodeObject(codec, data, this.context);
-    return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), data, encoded);
-  }
 }
 
 type PreimagesState = Pick<State, "getService">;
@@ -20358,7 +20581,6 @@ declare enum PreimagesErrorCode {
   AccountNotFound = "account_not_found",
 }
 
-// TODO [SeKo] consider whether this module is the right place to remove expired preimages
 declare class Preimages {
   constructor(
     public readonly state: PreimagesState,
@@ -20445,4 +20667,4 @@ declare namespace index {
   export type { index_PreimagesInput as PreimagesInput, index_PreimagesState as PreimagesState, index_PreimagesStateUpdate as PreimagesStateUpdate };
 }
 
-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$3 as pvm, index$5 as pvm_host_calls, index$6 as pvm_interpreter, index$7 as pvm_program, index$8 as pvm_spi_decoder, index$2 as shuffling, index$e as state, index$1 as state_json, index$d as state_merkleization, index as transition, index$g as trie, index$u as utils };
+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 };