@typeberry/lib 0.1.2 → 0.1.3-707962d

package/index.d.ts

@@ -708,59 +708,59 @@ declare function isResult(x: unknown): x is Result$2<unknown, unknown> {
  * as an afterthought.
  */
 
-declare const index$s_ALL_VERSIONS_IN_ORDER: typeof ALL_VERSIONS_IN_ORDER;
-declare const index$s_CURRENT_SUITE: typeof CURRENT_SUITE;
-declare const index$s_CURRENT_VERSION: typeof CURRENT_VERSION;
-type index$s_Compatibility = Compatibility;
-declare const index$s_Compatibility: typeof Compatibility;
-declare const index$s_DEFAULT_SUITE: typeof DEFAULT_SUITE;
-declare const index$s_DEFAULT_VERSION: typeof DEFAULT_VERSION;
-type index$s_DeepEqualOptions = DeepEqualOptions;
-type index$s_EnumMapping = EnumMapping;
-type index$s_ErrorResult<Error> = ErrorResult<Error>;
-type index$s_ErrorsCollector = ErrorsCollector;
-declare const index$s_ErrorsCollector: typeof ErrorsCollector;
-type index$s_GpVersion = GpVersion;
-declare const index$s_GpVersion: typeof GpVersion;
-type index$s_OK = OK;
-type index$s_OkResult<Ok> = OkResult<Ok>;
-type index$s_Opaque<Type, Token extends string> = Opaque<Type, Token>;
-type index$s_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
-declare const index$s_RichTaggedError: typeof RichTaggedError;
-type index$s_StringLiteral<Type> = StringLiteral<Type>;
-declare const index$s_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
-type index$s_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
-type index$s_TestSuite = TestSuite;
-declare const index$s_TestSuite: typeof TestSuite;
-type index$s_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
-type index$s_Uninstantiable = Uninstantiable;
-type index$s_WithDebug = WithDebug;
-declare const index$s_WithDebug: typeof WithDebug;
-type index$s_WithOpaque<Token extends string> = WithOpaque<Token>;
-declare const index$s___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
-declare const index$s_asOpaqueType: typeof asOpaqueType;
-declare const index$s_assertEmpty: typeof assertEmpty;
-declare const index$s_assertNever: typeof assertNever;
-declare const index$s_callCompareFunction: typeof callCompareFunction;
-declare const index$s_check: typeof check;
-declare const index$s_deepEqual: typeof deepEqual;
-declare const index$s_getAllKeysSorted: typeof getAllKeysSorted;
-declare const index$s_inspect: typeof inspect;
-declare const index$s_isBrowser: typeof isBrowser;
-declare const index$s_isResult: typeof isResult;
-declare const index$s_isTaggedError: typeof isTaggedError;
-declare const index$s_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
-declare const index$s_measure: typeof measure;
-declare const index$s_oomWarningPrinted: typeof oomWarningPrinted;
-declare const index$s_parseCurrentSuite: typeof parseCurrentSuite;
-declare const index$s_parseCurrentVersion: typeof parseCurrentVersion;
-declare const index$s_resultToString: typeof resultToString;
-declare const index$s_seeThrough: typeof seeThrough;
-declare const index$s_trimStack: typeof trimStack;
-declare const index$s_workspacePathFix: typeof workspacePathFix;
-declare namespace index$s {
-  export { index$s_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$s_CURRENT_SUITE as CURRENT_SUITE, index$s_CURRENT_VERSION as CURRENT_VERSION, index$s_Compatibility as Compatibility, index$s_DEFAULT_SUITE as DEFAULT_SUITE, index$s_DEFAULT_VERSION as DEFAULT_VERSION, index$s_ErrorsCollector as ErrorsCollector, index$s_GpVersion as GpVersion, Result$2 as Result, index$s_RichTaggedError as RichTaggedError, index$s_TEST_COMPARE_USING as TEST_COMPARE_USING, index$s_TestSuite as TestSuite, index$s_WithDebug as WithDebug, index$s___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$s_asOpaqueType as asOpaqueType, index$s_assertEmpty as assertEmpty, index$s_assertNever as assertNever, index$s_callCompareFunction as callCompareFunction, index$s_check as check, index$s_deepEqual as deepEqual, index$s_getAllKeysSorted as getAllKeysSorted, index$s_inspect as inspect, index$s_isBrowser as isBrowser, index$s_isResult as isResult, index$s_isTaggedError as isTaggedError, index$s_maybeTaggedErrorToString as maybeTaggedErrorToString, index$s_measure as measure, index$s_oomWarningPrinted as oomWarningPrinted, index$s_parseCurrentSuite as parseCurrentSuite, index$s_parseCurrentVersion as parseCurrentVersion, index$s_resultToString as resultToString, index$s_seeThrough as seeThrough, index$s_trimStack as trimStack, index$s_workspacePathFix as workspacePathFix };
-  export type { index$s_DeepEqualOptions as DeepEqualOptions, index$s_EnumMapping as EnumMapping, index$s_ErrorResult as ErrorResult, index$s_OK as OK, index$s_OkResult as OkResult, index$s_Opaque as Opaque, index$s_StringLiteral as StringLiteral, index$s_TaggedError as TaggedError, index$s_TokenOf as TokenOf, index$s_Uninstantiable as Uninstantiable, index$s_WithOpaque as WithOpaque };
+declare const index$u_ALL_VERSIONS_IN_ORDER: typeof ALL_VERSIONS_IN_ORDER;
+declare const index$u_CURRENT_SUITE: typeof CURRENT_SUITE;
+declare const index$u_CURRENT_VERSION: typeof CURRENT_VERSION;
+type index$u_Compatibility = Compatibility;
+declare const index$u_Compatibility: typeof Compatibility;
+declare const index$u_DEFAULT_SUITE: typeof DEFAULT_SUITE;
+declare const index$u_DEFAULT_VERSION: typeof DEFAULT_VERSION;
+type index$u_DeepEqualOptions = DeepEqualOptions;
+type index$u_EnumMapping = EnumMapping;
+type index$u_ErrorResult<Error> = ErrorResult<Error>;
+type index$u_ErrorsCollector = ErrorsCollector;
+declare const index$u_ErrorsCollector: typeof ErrorsCollector;
+type index$u_GpVersion = GpVersion;
+declare const index$u_GpVersion: typeof GpVersion;
+type index$u_OK = OK;
+type index$u_OkResult<Ok> = OkResult<Ok>;
+type index$u_Opaque<Type, Token extends string> = Opaque<Type, Token>;
+type index$u_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
+declare const index$u_RichTaggedError: typeof RichTaggedError;
+type index$u_StringLiteral<Type> = StringLiteral<Type>;
+declare const index$u_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
+type index$u_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
+type index$u_TestSuite = TestSuite;
+declare const index$u_TestSuite: typeof TestSuite;
+type index$u_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
+type index$u_Uninstantiable = Uninstantiable;
+type index$u_WithDebug = WithDebug;
+declare const index$u_WithDebug: typeof WithDebug;
+type index$u_WithOpaque<Token extends string> = WithOpaque<Token>;
+declare const index$u___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
+declare const index$u_asOpaqueType: typeof asOpaqueType;
+declare const index$u_assertEmpty: typeof assertEmpty;
+declare const index$u_assertNever: typeof assertNever;
+declare const index$u_callCompareFunction: typeof callCompareFunction;
+declare const index$u_check: typeof check;
+declare const index$u_deepEqual: typeof deepEqual;
+declare const index$u_getAllKeysSorted: typeof getAllKeysSorted;
+declare const index$u_inspect: typeof inspect;
+declare const index$u_isBrowser: typeof isBrowser;
+declare const index$u_isResult: typeof isResult;
+declare const index$u_isTaggedError: typeof isTaggedError;
+declare const index$u_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_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, 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_seeThrough as seeThrough, index$u_trimStack as trimStack, index$u_workspacePathFix as workspacePathFix };
+  export type { index$u_DeepEqualOptions as DeepEqualOptions, index$u_EnumMapping as EnumMapping, index$u_ErrorResult as ErrorResult, index$u_OK as OK, index$u_OkResult as OkResult, index$u_Opaque as Opaque, index$u_StringLiteral as StringLiteral, index$u_TaggedError as TaggedError, index$u_TokenOf as TokenOf, index$u_Uninstantiable as Uninstantiable, index$u_WithOpaque as WithOpaque };
 }
 
 /** A return value of some comparator. */
@@ -813,14 +813,14 @@ declare class Ordering {
  */
 type Comparator<V> = (self: V, other: V) => Ordering;
 
-type index$r_Comparator<V> = Comparator<V>;
-type index$r_Ordering = Ordering;
-declare const index$r_Ordering: typeof Ordering;
-type index$r_OrderingValue = OrderingValue;
-declare const index$r_OrderingValue: typeof OrderingValue;
-declare namespace index$r {
-  export { index$r_Ordering as Ordering, index$r_OrderingValue as OrderingValue };
-  export type { index$r_Comparator as Comparator };
+type index$t_Comparator<V> = Comparator<V>;
+type index$t_Ordering = Ordering;
+declare const index$t_Ordering: typeof Ordering;
+type index$t_OrderingValue = OrderingValue;
+declare const index$t_OrderingValue: typeof OrderingValue;
+declare namespace index$t {
+  export { index$t_Ordering as Ordering, index$t_OrderingValue as OrderingValue };
+  export type { index$t_Comparator as Comparator };
 }
 
 // TODO: [MaSo] Update BytesBlob and Bytes, so they return Result (not throw error)
@@ -1213,41 +1213,41 @@ declare class BitVec {
   }
 }
 
-type index$q_BitVec = BitVec;
-declare const index$q_BitVec: typeof BitVec;
-type index$q_Bytes<T extends number> = Bytes<T>;
-declare const index$q_Bytes: typeof Bytes;
-type index$q_BytesBlob = BytesBlob;
-declare const index$q_BytesBlob: typeof BytesBlob;
-declare const index$q_CODE_OF_0: typeof CODE_OF_0;
-declare const index$q_CODE_OF_9: typeof CODE_OF_9;
-declare const index$q_CODE_OF_A: typeof CODE_OF_A;
-declare const index$q_CODE_OF_F: typeof CODE_OF_F;
-declare const index$q_CODE_OF_a: typeof CODE_OF_a;
-declare const index$q_CODE_OF_f: typeof CODE_OF_f;
-declare const index$q_VALUE_OF_A: typeof VALUE_OF_A;
-declare const index$q_byteFromString: typeof byteFromString;
-declare const index$q_bytesBlobComparator: typeof bytesBlobComparator;
-declare const index$q_bytesToHexString: typeof bytesToHexString;
-declare const index$q_numberFromCharCode: typeof numberFromCharCode;
-declare const index$q_u8ArraySameLengthEqual: typeof u8ArraySameLengthEqual;
-declare namespace index$q {
+type index$s_BitVec = BitVec;
+declare const index$s_BitVec: typeof BitVec;
+type index$s_Bytes<T extends number> = Bytes<T>;
+declare const index$s_Bytes: typeof Bytes;
+type index$s_BytesBlob = BytesBlob;
+declare const index$s_BytesBlob: typeof BytesBlob;
+declare const index$s_CODE_OF_0: typeof CODE_OF_0;
+declare const index$s_CODE_OF_9: typeof CODE_OF_9;
+declare const index$s_CODE_OF_A: typeof CODE_OF_A;
+declare const index$s_CODE_OF_F: typeof CODE_OF_F;
+declare const index$s_CODE_OF_a: typeof CODE_OF_a;
+declare const index$s_CODE_OF_f: typeof CODE_OF_f;
+declare const index$s_VALUE_OF_A: typeof VALUE_OF_A;
+declare const index$s_byteFromString: typeof byteFromString;
+declare const index$s_bytesBlobComparator: typeof bytesBlobComparator;
+declare const index$s_bytesToHexString: typeof bytesToHexString;
+declare const index$s_numberFromCharCode: typeof numberFromCharCode;
+declare const index$s_u8ArraySameLengthEqual: typeof u8ArraySameLengthEqual;
+declare namespace index$s {
   export {
-    index$q_BitVec as BitVec,
-    index$q_Bytes as Bytes,
-    index$q_BytesBlob as BytesBlob,
-    index$q_CODE_OF_0 as CODE_OF_0,
-    index$q_CODE_OF_9 as CODE_OF_9,
-    index$q_CODE_OF_A as CODE_OF_A,
-    index$q_CODE_OF_F as CODE_OF_F,
-    index$q_CODE_OF_a as CODE_OF_a,
-    index$q_CODE_OF_f as CODE_OF_f,
-    index$q_VALUE_OF_A as VALUE_OF_A,
-    index$q_byteFromString as byteFromString,
-    index$q_bytesBlobComparator as bytesBlobComparator,
-    index$q_bytesToHexString as bytesToHexString,
-    index$q_numberFromCharCode as numberFromCharCode,
-    index$q_u8ArraySameLengthEqual as u8ArraySameLengthEqual,
+    index$s_BitVec as BitVec,
+    index$s_Bytes as Bytes,
+    index$s_BytesBlob as BytesBlob,
+    index$s_CODE_OF_0 as CODE_OF_0,
+    index$s_CODE_OF_9 as CODE_OF_9,
+    index$s_CODE_OF_A as CODE_OF_A,
+    index$s_CODE_OF_F as CODE_OF_F,
+    index$s_CODE_OF_a as CODE_OF_a,
+    index$s_CODE_OF_f as CODE_OF_f,
+    index$s_VALUE_OF_A as VALUE_OF_A,
+    index$s_byteFromString as byteFromString,
+    index$s_bytesBlobComparator as bytesBlobComparator,
+    index$s_bytesToHexString as bytesToHexString,
+    index$s_numberFromCharCode as numberFromCharCode,
+    index$s_u8ArraySameLengthEqual as u8ArraySameLengthEqual,
   };
 }
 
@@ -1395,37 +1395,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$p_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
-declare const index$p_MAX_VALUE_U16: typeof MAX_VALUE_U16;
-declare const index$p_MAX_VALUE_U32: typeof MAX_VALUE_U32;
-declare const index$p_MAX_VALUE_U64: typeof MAX_VALUE_U64;
-declare const index$p_MAX_VALUE_U8: typeof MAX_VALUE_U8;
-type index$p_U16 = U16;
-type index$p_U32 = U32;
-type index$p_U64 = U64;
-type index$p_U8 = U8;
-type index$p_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
-declare const index$p___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
-declare const index$p_asTypedNumber: typeof asTypedNumber;
-declare const index$p_isU16: typeof isU16;
-declare const index$p_isU32: typeof isU32;
-declare const index$p_isU64: typeof isU64;
-declare const index$p_isU8: typeof isU8;
-declare const index$p_leBytesAsU32: typeof leBytesAsU32;
-declare const index$p_maxU64: typeof maxU64;
-declare const index$p_minU64: typeof minU64;
-declare const index$p_sumU32: typeof sumU32;
-declare const index$p_sumU64: typeof sumU64;
-declare const index$p_tryAsU16: typeof tryAsU16;
-declare const index$p_tryAsU32: typeof tryAsU32;
-declare const index$p_tryAsU64: typeof tryAsU64;
-declare const index$p_tryAsU8: typeof tryAsU8;
-declare const index$p_u32AsLeBytes: typeof u32AsLeBytes;
-declare const index$p_u64FromParts: typeof u64FromParts;
-declare const index$p_u64IntoParts: typeof u64IntoParts;
-declare namespace index$p {
-  export { index$p_MAX_VALUE_U16 as MAX_VALUE_U16, index$p_MAX_VALUE_U32 as MAX_VALUE_U32, index$p_MAX_VALUE_U64 as MAX_VALUE_U64, index$p_MAX_VALUE_U8 as MAX_VALUE_U8, index$p___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$p_asTypedNumber as asTypedNumber, index$p_isU16 as isU16, index$p_isU32 as isU32, index$p_isU64 as isU64, index$p_isU8 as isU8, index$p_leBytesAsU32 as leBytesAsU32, index$p_maxU64 as maxU64, index$p_minU64 as minU64, index$p_sumU32 as sumU32, index$p_sumU64 as sumU64, index$p_tryAsU16 as tryAsU16, index$p_tryAsU32 as tryAsU32, index$p_tryAsU64 as tryAsU64, index$p_tryAsU8 as tryAsU8, index$p_u32AsLeBytes as u32AsLeBytes, index$p_u64FromParts as u64FromParts, index$p_u64IntoParts as u64IntoParts };
-  export type { index$p_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$p_U16 as U16, index$p_U32 as U32, index$p_U64 as U64, index$p_U8 as U8, index$p_WithBytesRepresentation as WithBytesRepresentation };
+type index$r_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
+declare const index$r_MAX_VALUE_U16: typeof MAX_VALUE_U16;
+declare const index$r_MAX_VALUE_U32: typeof MAX_VALUE_U32;
+declare const index$r_MAX_VALUE_U64: typeof MAX_VALUE_U64;
+declare const index$r_MAX_VALUE_U8: typeof MAX_VALUE_U8;
+type index$r_U16 = U16;
+type index$r_U32 = U32;
+type index$r_U64 = U64;
+type index$r_U8 = U8;
+type index$r_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
+declare const index$r___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
+declare const index$r_asTypedNumber: typeof asTypedNumber;
+declare const index$r_isU16: typeof isU16;
+declare const index$r_isU32: typeof isU32;
+declare const index$r_isU64: typeof isU64;
+declare const index$r_isU8: typeof isU8;
+declare const index$r_leBytesAsU32: typeof leBytesAsU32;
+declare const index$r_maxU64: typeof maxU64;
+declare const index$r_minU64: typeof minU64;
+declare const index$r_sumU32: typeof sumU32;
+declare const index$r_sumU64: typeof sumU64;
+declare const index$r_tryAsU16: typeof tryAsU16;
+declare const index$r_tryAsU32: typeof tryAsU32;
+declare const index$r_tryAsU64: typeof tryAsU64;
+declare const index$r_tryAsU8: typeof tryAsU8;
+declare const index$r_u32AsLeBytes: typeof u32AsLeBytes;
+declare const index$r_u64FromParts: typeof u64FromParts;
+declare const index$r_u64IntoParts: typeof u64IntoParts;
+declare namespace index$r {
+  export { index$r_MAX_VALUE_U16 as MAX_VALUE_U16, index$r_MAX_VALUE_U32 as MAX_VALUE_U32, index$r_MAX_VALUE_U64 as MAX_VALUE_U64, index$r_MAX_VALUE_U8 as MAX_VALUE_U8, index$r___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$r_asTypedNumber as asTypedNumber, index$r_isU16 as isU16, index$r_isU32 as isU32, index$r_isU64 as isU64, index$r_isU8 as isU8, index$r_leBytesAsU32 as leBytesAsU32, index$r_maxU64 as maxU64, index$r_minU64 as minU64, index$r_sumU32 as sumU32, index$r_sumU64 as sumU64, index$r_tryAsU16 as tryAsU16, index$r_tryAsU32 as tryAsU32, index$r_tryAsU64 as tryAsU64, index$r_tryAsU8 as tryAsU8, index$r_u32AsLeBytes as u32AsLeBytes, index$r_u64FromParts as u64FromParts, index$r_u64IntoParts as u64IntoParts };
+  export type { index$r_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$r_U16 as U16, index$r_U32 as U32, index$r_U64 as U64, index$r_U8 as U8, index$r_WithBytesRepresentation as WithBytesRepresentation };
 }
 
 /** A decoder for some specific type `T` */
@@ -2527,6 +2527,7 @@ declare class ViewField<T, V> implements ViewField<T, V> {
   private cachedBlob: BytesBlob | undefined;
 
   constructor(
+    private readonly name: string,
     private readonly getView: () => V,
     private readonly getValue: () => T,
     private readonly getEncoded: () => BytesBlob,
@@ -2555,6 +2556,10 @@ declare class ViewField<T, V> implements ViewField<T, V> {
     }
     return this.cachedBlob;
   }
+
+  toString() {
+    return `ViewField<${this.name}>`;
+  }
 }
 
 /**
@@ -2638,6 +2643,7 @@ declare abstract class ObjectView<T> {
       const field = this.descriptorsKeys[i];
       const type = this.descriptors[field as keyof DescriptorRecord<T>];
       lastItem = new ViewField(
+        `${this.toString()}.${String(field)}`,
         () => type.View.decode(fieldDecoder.clone()),
         () => type.decode(fieldDecoder.clone()),
         () => type.skipEncoded(fieldDecoder.clone()),
@@ -2655,6 +2661,10 @@ declare abstract class ObjectView<T> {
 
     return lastItem as ViewField<T[K], unknown>;
   }
+
+  toString() {
+    return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
+  }
 }
 
 /**
@@ -2755,6 +2765,7 @@ declare class SequenceView<T, V = T> {
       const fieldDecoder = skipper.decoder.clone();
       const type = this.descriptor;
       lastItem = new ViewField(
+        `${this.toString()}[${index}]`,
         () => type.View.decode(fieldDecoder.clone()),
         () => type.decode(fieldDecoder.clone()),
         () => type.skipEncoded(fieldDecoder.clone()),
@@ -2771,6 +2782,10 @@ declare class SequenceView<T, V = T> {
     }
     return lastItem;
   }
+
+  toString() {
+    return `SequenceView<${this.descriptor.name}>(cache: ${this.cache.size})`;
+  }
 }
 
 /**
@@ -3400,50 +3415,50 @@ declare function sequenceViewFixLen<T, V>(
   );
 }
 
-type index$o_ClassConstructor<T> = ClassConstructor<T>;
-type index$o_Codec<T> = Codec<T>;
-type index$o_CodecRecord<T> = CodecRecord<T>;
-declare const index$o_DEFAULT_START_LENGTH: typeof DEFAULT_START_LENGTH;
-type index$o_Decode<T> = Decode<T>;
-type index$o_Decoder = Decoder;
-declare const index$o_Decoder: typeof Decoder;
-type index$o_DescribedBy<T> = DescribedBy<T>;
-type index$o_Descriptor<T, V = T> = Descriptor<T, V>;
-declare const index$o_Descriptor: typeof Descriptor;
-type index$o_DescriptorRecord<T> = DescriptorRecord<T>;
-type index$o_Encode<T> = Encode<T>;
-type index$o_Encoder = Encoder;
-declare const index$o_Encoder: typeof Encoder;
-type index$o_LengthRange = LengthRange;
-declare const index$o_MASKS: typeof MASKS;
-declare const index$o_MAX_LENGTH: typeof MAX_LENGTH;
-type index$o_ObjectView<T> = ObjectView<T>;
-declare const index$o_ObjectView: typeof ObjectView;
-type index$o_OptionalRecord<T> = OptionalRecord<T>;
-type index$o_PropertyKeys<T> = PropertyKeys<T>;
-type index$o_SequenceView<T, V = T> = SequenceView<T, V>;
-declare const index$o_SequenceView: typeof SequenceView;
-type index$o_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
-type index$o_SizeHint = SizeHint;
-declare const index$o_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
-declare const index$o_TYPICAL_SEQUENCE_LENGTH: typeof TYPICAL_SEQUENCE_LENGTH;
-type index$o_ViewField<T, V> = ViewField<T, V>;
-declare const index$o_ViewField: typeof ViewField;
-type index$o_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
-declare const index$o_addSizeHints: typeof addSizeHints;
-declare const index$o_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
-declare const index$o_exactHint: typeof exactHint;
-declare const index$o_forEachDescriptor: typeof forEachDescriptor;
-declare const index$o_hasUniqueView: typeof hasUniqueView;
-declare const index$o_objectView: typeof objectView;
-declare const index$o_readonlyArray: typeof readonlyArray;
-declare const index$o_sequenceViewFixLen: typeof sequenceViewFixLen;
-declare const index$o_sequenceViewVarLen: typeof sequenceViewVarLen;
-declare const index$o_tryAsExactBytes: typeof tryAsExactBytes;
-declare const index$o_validateLength: typeof validateLength;
-declare namespace index$o {
-  export { index$o_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$o_Decoder as Decoder, index$o_Descriptor as Descriptor, index$o_Encoder as Encoder, index$o_MASKS as MASKS, index$o_MAX_LENGTH as MAX_LENGTH, index$o_ObjectView as ObjectView, index$o_SequenceView as SequenceView, index$o_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$o_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$o_ViewField as ViewField, index$o_addSizeHints as addSizeHints, codec$1 as codec, index$o_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$o_exactHint as exactHint, index$o_forEachDescriptor as forEachDescriptor, index$o_hasUniqueView as hasUniqueView, index$o_objectView as objectView, index$o_readonlyArray as readonlyArray, index$o_sequenceViewFixLen as sequenceViewFixLen, index$o_sequenceViewVarLen as sequenceViewVarLen, index$o_tryAsExactBytes as tryAsExactBytes, index$o_validateLength as validateLength };
-  export type { index$o_ClassConstructor as ClassConstructor, index$o_Codec as Codec, index$o_CodecRecord as CodecRecord, index$o_Decode as Decode, index$o_DescribedBy as DescribedBy, index$o_DescriptorRecord as DescriptorRecord, index$o_Encode as Encode, index$o_LengthRange as LengthRange, index$o_OptionalRecord as OptionalRecord, Options$1 as Options, index$o_PropertyKeys as PropertyKeys, index$o_SimpleDescriptorRecord as SimpleDescriptorRecord, index$o_SizeHint as SizeHint, index$o_ViewOf as ViewOf };
+type index$q_ClassConstructor<T> = ClassConstructor<T>;
+type index$q_Codec<T> = Codec<T>;
+type index$q_CodecRecord<T> = CodecRecord<T>;
+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_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_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_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 };
 }
 
 /**
@@ -3666,28 +3681,28 @@ declare namespace keccak {
   };
 }
 
-type index$n_Blake2bHash = Blake2bHash;
-type index$n_HASH_SIZE = HASH_SIZE;
-type index$n_HashAllocator = HashAllocator;
-type index$n_KeccakHash = KeccakHash;
-type index$n_OpaqueHash = OpaqueHash;
-type index$n_PageAllocator = PageAllocator;
-declare const index$n_PageAllocator: typeof PageAllocator;
-type index$n_SimpleAllocator = SimpleAllocator;
-declare const index$n_SimpleAllocator: typeof SimpleAllocator;
-type index$n_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
-type index$n_TruncatedHash = TruncatedHash;
-type index$n_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
-declare const index$n_WithHash: typeof WithHash;
-type index$n_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
-declare const index$n_WithHashAndBytes: typeof WithHashAndBytes;
-declare const index$n_ZERO_HASH: typeof ZERO_HASH;
-declare const index$n_blake2b: typeof blake2b;
-declare const index$n_defaultAllocator: typeof defaultAllocator;
-declare const index$n_keccak: typeof keccak;
-declare namespace index$n {
-  export { index$n_PageAllocator as PageAllocator, index$n_SimpleAllocator as SimpleAllocator, index$n_WithHash as WithHash, index$n_WithHashAndBytes as WithHashAndBytes, index$n_ZERO_HASH as ZERO_HASH, index$n_blake2b as blake2b, index$n_defaultAllocator as defaultAllocator, index$n_keccak as keccak };
-  export type { index$n_Blake2bHash as Blake2bHash, index$n_HASH_SIZE as HASH_SIZE, index$n_HashAllocator as HashAllocator, index$n_KeccakHash as KeccakHash, index$n_OpaqueHash as OpaqueHash, index$n_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$n_TruncatedHash as TruncatedHash };
+type index$p_Blake2bHash = Blake2bHash;
+type index$p_HASH_SIZE = HASH_SIZE;
+type index$p_HashAllocator = HashAllocator;
+type index$p_KeccakHash = KeccakHash;
+type index$p_OpaqueHash = OpaqueHash;
+type index$p_PageAllocator = PageAllocator;
+declare const index$p_PageAllocator: typeof PageAllocator;
+type index$p_SimpleAllocator = SimpleAllocator;
+declare const index$p_SimpleAllocator: typeof SimpleAllocator;
+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_blake2b: typeof blake2b;
+declare const index$p_defaultAllocator: typeof defaultAllocator;
+declare const index$p_keccak: typeof keccak;
+declare namespace index$p {
+  export { index$p_PageAllocator as PageAllocator, index$p_SimpleAllocator as SimpleAllocator, index$p_WithHash as WithHash, index$p_WithHashAndBytes as WithHashAndBytes, index$p_ZERO_HASH as ZERO_HASH, index$p_blake2b as blake2b, index$p_defaultAllocator as defaultAllocator, index$p_keccak as keccak };
+  export type { index$p_Blake2bHash as Blake2bHash, index$p_HASH_SIZE as HASH_SIZE, index$p_HashAllocator as HashAllocator, index$p_KeccakHash as KeccakHash, index$p_OpaqueHash as OpaqueHash, index$p_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$p_TruncatedHash as TruncatedHash };
 }
 
 /** Immutable view of the `HashDictionary`. */
@@ -4464,35 +4479,35 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 }
 
-type index$m_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
-declare const index$m_FixedSizeArray: typeof FixedSizeArray;
-type index$m_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
-declare const index$m_HashDictionary: typeof HashDictionary;
-type index$m_HashSet<V extends OpaqueHash> = HashSet<V>;
-declare const index$m_HashSet: typeof HashSet;
-type index$m_HashWithZeroedBit<T extends OpaqueHash> = HashWithZeroedBit<T>;
-type index$m_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
-type index$m_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
-type index$m_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
-type index$m_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
-type index$m_KeyMapper<K> = KeyMapper<K>;
-type index$m_KeyMappers<TKeys extends readonly unknown[]> = KeyMappers<TKeys>;
-type index$m_KnownSize<T, F extends string> = KnownSize<T, F>;
-type index$m_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
-type index$m_KnownSizeId<X> = KnownSizeId<X>;
-type index$m_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
-declare const index$m_MultiMap: typeof MultiMap;
-type index$m_NestedMaps<TKeys extends readonly unknown[], TValue> = NestedMaps<TKeys, TValue>;
-type index$m_SortedArray<V> = SortedArray<V>;
-declare const index$m_SortedArray: typeof SortedArray;
-type index$m_SortedSet<V> = SortedSet<V>;
-declare const index$m_SortedSet: typeof SortedSet;
-type index$m_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
-declare const index$m_TruncatedHashDictionary: typeof TruncatedHashDictionary;
-declare const index$m_asKnownSize: typeof asKnownSize;
-declare namespace index$m {
-  export { index$m_FixedSizeArray as FixedSizeArray, index$m_HashDictionary as HashDictionary, index$m_HashSet as HashSet, index$m_MultiMap as MultiMap, index$m_SortedArray as SortedArray, index$m_SortedSet as SortedSet, index$m_TruncatedHashDictionary as TruncatedHashDictionary, index$m_asKnownSize as asKnownSize };
-  export type { index$m_HashWithZeroedBit as HashWithZeroedBit, index$m_ImmutableHashDictionary as ImmutableHashDictionary, index$m_ImmutableHashSet as ImmutableHashSet, index$m_ImmutableSortedArray as ImmutableSortedArray, index$m_ImmutableSortedSet as ImmutableSortedSet, index$m_KeyMapper as KeyMapper, index$m_KeyMappers as KeyMappers, index$m_KnownSize as KnownSize, index$m_KnownSizeArray as KnownSizeArray, index$m_KnownSizeId as KnownSizeId, index$m_NestedMaps as NestedMaps };
+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_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 };
 }
 
 declare namespace bandersnatch_d_exports {
@@ -4858,32 +4873,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$l_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
-type index$l_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
-type index$l_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
-type index$l_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
-type index$l_BLS_KEY_BYTES = BLS_KEY_BYTES;
-type index$l_BandersnatchKey = BandersnatchKey;
-type index$l_BandersnatchProof = BandersnatchProof;
-type index$l_BandersnatchRingRoot = BandersnatchRingRoot;
-type index$l_BandersnatchSecretSeed = BandersnatchSecretSeed;
-type index$l_BandersnatchVrfSignature = BandersnatchVrfSignature;
-type index$l_BlsKey = BlsKey;
-type index$l_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
-type index$l_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
-type index$l_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
-type index$l_Ed25519Key = Ed25519Key;
-type index$l_Ed25519Pair = Ed25519Pair;
-declare const index$l_Ed25519Pair: typeof Ed25519Pair;
-type index$l_Ed25519SecretSeed = Ed25519SecretSeed;
-type index$l_Ed25519Signature = Ed25519Signature;
-type index$l_SEED_SIZE = SEED_SIZE;
-declare const index$l_bandersnatch: typeof bandersnatch;
-declare const index$l_ed25519: typeof ed25519;
-declare const index$l_keyDerivation: typeof keyDerivation;
-declare namespace index$l {
-  export { index$l_Ed25519Pair as Ed25519Pair, index$l_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$l_ed25519 as ed25519, initAll as initWasm, index$l_keyDerivation as keyDerivation };
-  export type { index$l_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$l_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$l_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$l_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$l_BLS_KEY_BYTES as BLS_KEY_BYTES, index$l_BandersnatchKey as BandersnatchKey, index$l_BandersnatchProof as BandersnatchProof, index$l_BandersnatchRingRoot as BandersnatchRingRoot, index$l_BandersnatchSecretSeed as BandersnatchSecretSeed, index$l_BandersnatchVrfSignature as BandersnatchVrfSignature, index$l_BlsKey as BlsKey, index$l_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$l_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$l_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$l_Ed25519Key as Ed25519Key, index$l_Ed25519SecretSeed as Ed25519SecretSeed, index$l_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$l_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 };
 }
 
 /**
@@ -5080,24 +5095,24 @@ declare class Bootnode implements PeerAddress {
   }
 }
 
-type index$k_Bootnode = Bootnode;
-declare const index$k_Bootnode: typeof Bootnode;
-type index$k_ChainSpec = ChainSpec;
-declare const index$k_ChainSpec: typeof ChainSpec;
-declare const index$k_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
-declare const index$k_EST_CORES: typeof EST_CORES;
-declare const index$k_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
-declare const index$k_EST_VALIDATORS: typeof EST_VALIDATORS;
-declare const index$k_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
-type index$k_PeerAddress = PeerAddress;
-type index$k_PeerId = PeerId;
-type index$k_WorkerConfig = WorkerConfig;
-declare const index$k_WorkerConfig: typeof WorkerConfig;
-declare const index$k_fullChainSpec: typeof fullChainSpec;
-declare const index$k_tinyChainSpec: typeof tinyChainSpec;
-declare namespace index$k {
-  export { index$k_Bootnode as Bootnode, index$k_ChainSpec as ChainSpec, index$k_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$k_EST_CORES as EST_CORES, index$k_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$k_EST_VALIDATORS as EST_VALIDATORS, index$k_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$k_WorkerConfig as WorkerConfig, index$k_fullChainSpec as fullChainSpec, index$k_tinyChainSpec as tinyChainSpec };
-  export type { index$k_PeerAddress as PeerAddress, index$k_PeerId as PeerId };
+type index$m_Bootnode = Bootnode;
+declare const index$m_Bootnode: typeof Bootnode;
+type index$m_ChainSpec = ChainSpec;
+declare const index$m_ChainSpec: typeof ChainSpec;
+declare const index$m_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
+declare const index$m_EST_CORES: typeof EST_CORES;
+declare const index$m_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
+declare const index$m_EST_VALIDATORS: typeof EST_VALIDATORS;
+declare const index$m_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
+type index$m_PeerAddress = PeerAddress;
+type index$m_PeerId = PeerId;
+type index$m_WorkerConfig = WorkerConfig;
+declare const index$m_WorkerConfig: typeof WorkerConfig;
+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_WorkerConfig as WorkerConfig, index$m_fullChainSpec as fullChainSpec, index$m_tinyChainSpec as tinyChainSpec };
+  export type { index$m_PeerAddress as PeerAddress, index$m_PeerId as PeerId };
 }
 
 /**
@@ -6873,72 +6888,92 @@ declare class Block extends WithDebug {
 /** Undecoded View of a [`Block`]. */
 type BlockView = DescribedBy<typeof Block.Codec.View>;
 
-type index$j_Block = Block;
-declare const index$j_Block: typeof Block;
-type index$j_BlockView = BlockView;
-type index$j_CodeHash = CodeHash;
-type index$j_CoreIndex = CoreIndex;
-type index$j_EntropyHash = EntropyHash;
-type index$j_Epoch = Epoch;
-type index$j_EpochMarker = EpochMarker;
-declare const index$j_EpochMarker: typeof EpochMarker;
-type index$j_EpochMarkerView = EpochMarkerView;
-type index$j_Extrinsic = Extrinsic;
-declare const index$j_Extrinsic: typeof Extrinsic;
-type index$j_ExtrinsicHash = ExtrinsicHash;
-type index$j_ExtrinsicView = ExtrinsicView;
-type index$j_Header = Header;
-declare const index$j_Header: typeof Header;
-type index$j_HeaderHash = HeaderHash;
-type index$j_HeaderView = HeaderView;
-type index$j_HeaderViewWithHash = HeaderViewWithHash;
-declare const index$j_HeaderViewWithHash: typeof HeaderViewWithHash;
-declare const index$j_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
-type index$j_PerEpochBlock<T> = PerEpochBlock<T>;
-type index$j_PerValidator<T> = PerValidator<T>;
-type index$j_SEGMENT_BYTES = SEGMENT_BYTES;
-type index$j_Segment = Segment;
-type index$j_SegmentIndex = SegmentIndex;
-type index$j_ServiceGas = ServiceGas;
-type index$j_ServiceId = ServiceId;
-type index$j_StateRootHash = StateRootHash;
-type index$j_TicketsMarker = TicketsMarker;
-declare const index$j_TicketsMarker: typeof TicketsMarker;
-type index$j_TicketsMarkerView = TicketsMarkerView;
-type index$j_TimeSlot = TimeSlot;
-type index$j_ValidatorIndex = ValidatorIndex;
-type index$j_ValidatorKeys = ValidatorKeys;
-declare const index$j_ValidatorKeys: typeof ValidatorKeys;
-declare const index$j_W_E: typeof W_E;
-declare const index$j_W_S: typeof W_S;
-type index$j_WorkReportHash = WorkReportHash;
-declare const index$j_assurances: typeof assurances;
-declare const index$j_codecPerEpochBlock: typeof codecPerEpochBlock;
-declare const index$j_codecPerValidator: typeof codecPerValidator;
-declare const index$j_disputes: typeof disputes;
-declare const index$j_encodeUnsealedHeader: typeof encodeUnsealedHeader;
-declare const index$j_guarantees: typeof guarantees;
-declare const index$j_headerViewWithHashCodec: typeof headerViewWithHashCodec;
-declare const index$j_legacyDescriptor: typeof legacyDescriptor;
-declare const index$j_preimage: typeof preimage;
-declare const index$j_refineContext: typeof refineContext;
-declare const index$j_tickets: typeof tickets;
-declare const index$j_tryAsCoreIndex: typeof tryAsCoreIndex;
-declare const index$j_tryAsEpoch: typeof tryAsEpoch;
-declare const index$j_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
-declare const index$j_tryAsPerValidator: typeof tryAsPerValidator;
-declare const index$j_tryAsSegmentIndex: typeof tryAsSegmentIndex;
-declare const index$j_tryAsServiceGas: typeof tryAsServiceGas;
-declare const index$j_tryAsServiceId: typeof tryAsServiceId;
-declare const index$j_tryAsTimeSlot: typeof tryAsTimeSlot;
-declare const index$j_tryAsValidatorIndex: typeof tryAsValidatorIndex;
-declare const index$j_workItem: typeof workItem;
-declare const index$j_workPackage: typeof workPackage;
-declare const index$j_workReport: typeof workReport;
-declare const index$j_workResult: typeof workResult;
-declare namespace index$j {
-  export { index$j_Block as Block, index$j_EpochMarker as EpochMarker, index$j_Extrinsic as Extrinsic, index$j_Header as Header, index$j_HeaderViewWithHash as HeaderViewWithHash, index$j_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$j_TicketsMarker as TicketsMarker, index$j_ValidatorKeys as ValidatorKeys, index$j_W_E as W_E, index$j_W_S as W_S, index$j_assurances as assurances, index$j_codecPerEpochBlock as codecPerEpochBlock, index$j_codecPerValidator as codecPerValidator, codec as codecUtils, index$j_disputes as disputes, index$j_encodeUnsealedHeader as encodeUnsealedHeader, index$j_guarantees as guarantees, index$j_headerViewWithHashCodec as headerViewWithHashCodec, index$j_legacyDescriptor as legacyDescriptor, index$j_preimage as preimage, index$j_refineContext as refineContext, index$j_tickets as tickets, index$j_tryAsCoreIndex as tryAsCoreIndex, index$j_tryAsEpoch as tryAsEpoch, index$j_tryAsPerEpochBlock as tryAsPerEpochBlock, index$j_tryAsPerValidator as tryAsPerValidator, index$j_tryAsSegmentIndex as tryAsSegmentIndex, index$j_tryAsServiceGas as tryAsServiceGas, index$j_tryAsServiceId as tryAsServiceId, index$j_tryAsTimeSlot as tryAsTimeSlot, index$j_tryAsValidatorIndex as tryAsValidatorIndex, index$j_workItem as workItem, index$j_workPackage as workPackage, index$j_workReport as workReport, index$j_workResult as workResult };
-  export type { index$j_BlockView as BlockView, index$j_CodeHash as CodeHash, index$j_CoreIndex as CoreIndex, index$j_EntropyHash as EntropyHash, index$j_Epoch as Epoch, index$j_EpochMarkerView as EpochMarkerView, index$j_ExtrinsicHash as ExtrinsicHash, index$j_ExtrinsicView as ExtrinsicView, index$j_HeaderHash as HeaderHash, index$j_HeaderView as HeaderView, index$j_PerEpochBlock as PerEpochBlock, index$j_PerValidator as PerValidator, index$j_SEGMENT_BYTES as SEGMENT_BYTES, index$j_Segment as Segment, index$j_SegmentIndex as SegmentIndex, index$j_ServiceGas as ServiceGas, index$j_ServiceId as ServiceId, index$j_StateRootHash as StateRootHash, index$j_TicketsMarkerView as TicketsMarkerView, index$j_TimeSlot as TimeSlot, index$j_ValidatorIndex as ValidatorIndex, index$j_WorkReportHash as WorkReportHash };
+declare function emptyBlock(slot: TimeSlot = tryAsTimeSlot(0)) {
+  const header = Header.empty();
+  header.timeSlotIndex = slot;
+  return Block.create({
+    header,
+    extrinsic: Extrinsic.create({
+      tickets: asKnownSize([]),
+      preimages: [],
+      assurances: asKnownSize([]),
+      guarantees: asKnownSize([]),
+      disputes: {
+        verdicts: [],
+        culprits: [],
+        faults: [],
+      },
+    }),
+  });
+}
+
+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_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_refineContext as refineContext, index$l_tickets as tickets, index$l_tryAsCoreIndex as tryAsCoreIndex, index$l_tryAsEpoch as tryAsEpoch, index$l_tryAsPerEpochBlock as tryAsPerEpochBlock, index$l_tryAsPerValidator as tryAsPerValidator, index$l_tryAsSegmentIndex as tryAsSegmentIndex, index$l_tryAsServiceGas as tryAsServiceGas, index$l_tryAsServiceId as tryAsServiceId, index$l_tryAsTimeSlot as tryAsTimeSlot, index$l_tryAsValidatorIndex as tryAsValidatorIndex, index$l_workItem as workItem, index$l_workPackage as workPackage, index$l_workReport as workReport, index$l_workResult as workResult };
+  export type { index$l_BlockView as BlockView, index$l_CodeHash as CodeHash, index$l_CoreIndex as CoreIndex, index$l_EntropyHash as EntropyHash, index$l_Epoch as Epoch, index$l_EpochMarkerView as EpochMarkerView, index$l_ExtrinsicHash as ExtrinsicHash, index$l_ExtrinsicView as ExtrinsicView, index$l_HeaderHash as HeaderHash, index$l_HeaderView as HeaderView, index$l_PerEpochBlock as PerEpochBlock, index$l_PerValidator as PerValidator, index$l_SEGMENT_BYTES as SEGMENT_BYTES, index$l_Segment as Segment, index$l_SegmentIndex as SegmentIndex, index$l_ServiceGas as ServiceGas, index$l_ServiceId as ServiceId, index$l_StateRootHash as StateRootHash, index$l_TicketsMarkerView as TicketsMarkerView, index$l_TimeSlot as TimeSlot, index$l_ValidatorIndex as ValidatorIndex, index$l_WorkReportHash as WorkReportHash };
 }
 
 /** A type that can be read from a JSON-parsed object. */
@@ -7236,21 +7271,21 @@ declare namespace json {
   }
 }
 
-type index$i_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
-type index$i_FromJson<T> = FromJson<T>;
-type index$i_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
-type index$i_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
-type index$i_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
-declare const index$i_NO_KEY: typeof NO_KEY;
-type index$i_ObjectFromJson<T> = ObjectFromJson<T>;
-type index$i_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
-declare const index$i_diffKeys: typeof diffKeys;
-import index$i_json = json;
-declare const index$i_parseFromJson: typeof parseFromJson;
-declare const index$i_parseOrThrow: typeof parseOrThrow;
-declare namespace index$i {
-  export { index$i_NO_KEY as NO_KEY, index$i_diffKeys as diffKeys, index$i_json as json, index$i_parseFromJson as parseFromJson, index$i_parseOrThrow as parseOrThrow };
-  export type { index$i_Builder as Builder, index$i_FromJson as FromJson, index$i_FromJsonOptional as FromJsonOptional, index$i_FromJsonPrimitive as FromJsonPrimitive, index$i_FromJsonWithParser as FromJsonWithParser, index$i_ObjectFromJson as ObjectFromJson, index$i_Parser as Parser };
+type index$k_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
+type index$k_FromJson<T> = FromJson<T>;
+type index$k_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
+type index$k_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
+type index$k_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
+declare const index$k_NO_KEY: typeof NO_KEY;
+type index$k_ObjectFromJson<T> = ObjectFromJson<T>;
+type index$k_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
+declare const index$k_diffKeys: typeof diffKeys;
+import index$k_json = json;
+declare const index$k_parseFromJson: typeof parseFromJson;
+declare const index$k_parseOrThrow: typeof parseOrThrow;
+declare namespace index$k {
+  export { index$k_NO_KEY as NO_KEY, index$k_diffKeys as diffKeys, index$k_json as json, index$k_parseFromJson as parseFromJson, index$k_parseOrThrow as parseOrThrow };
+  export type { index$k_Builder as Builder, index$k_FromJson as FromJson, index$k_FromJsonOptional as FromJsonOptional, index$k_FromJsonPrimitive as FromJsonPrimitive, index$k_FromJsonWithParser as FromJsonWithParser, index$k_ObjectFromJson as ObjectFromJson, index$k_Parser as Parser };
 }
 
 declare namespace fromJson {
@@ -7753,52 +7788,52 @@ declare const blockFromJson = (spec: ChainSpec) =>
     ({ header, extrinsic }) => Block.create({ header, extrinsic }),
   );
 
-type index$h_CamelToSnake<S extends string> = CamelToSnake<S>;
-type index$h_JsonCulprit = JsonCulprit;
-type index$h_JsonEpochMarker = JsonEpochMarker;
-type index$h_JsonFault = JsonFault;
-type index$h_JsonHeader = JsonHeader;
-type index$h_JsonJudgement = JsonJudgement;
-type index$h_JsonObject<T> = JsonObject<T>;
-type index$h_JsonRefineContext = JsonRefineContext;
-type index$h_JsonReportGuarantee = JsonReportGuarantee;
-type index$h_JsonVerdict = JsonVerdict;
-type index$h_JsonWorkExecResult = JsonWorkExecResult;
-type index$h_JsonWorkRefineLoad = JsonWorkRefineLoad;
-type index$h_JsonWorkReport = JsonWorkReport;
-type index$h_JsonWorkResult = JsonWorkResult;
-declare const index$h_bandersnatchVrfSignature: typeof bandersnatchVrfSignature;
-declare const index$h_blockFromJson: typeof blockFromJson;
-declare const index$h_culpritFromJson: typeof culpritFromJson;
-declare const index$h_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
-declare const index$h_epochMark: typeof epochMark;
-declare const index$h_faultFromJson: typeof faultFromJson;
-import index$h_fromJson = fromJson;
-declare const index$h_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
-declare const index$h_getAvailabilityAssuranceFromJson: typeof getAvailabilityAssuranceFromJson;
-declare const index$h_getExtrinsicFromJson: typeof getExtrinsicFromJson;
-declare const index$h_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
-declare const index$h_headerFromJson: typeof headerFromJson;
-declare const index$h_judgementFromJson: typeof judgementFromJson;
-declare const index$h_preimageFromJson: typeof preimageFromJson;
-declare const index$h_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
-declare const index$h_refineContextFromJson: typeof refineContextFromJson;
-declare const index$h_reportGuaranteeFromJson: typeof reportGuaranteeFromJson;
-declare const index$h_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
-declare const index$h_ticket: typeof ticket;
-declare const index$h_ticketEnvelopeFromJson: typeof ticketEnvelopeFromJson;
-declare const index$h_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
-declare const index$h_validatorKeysFromJson: typeof validatorKeysFromJson;
-declare const index$h_validatorSignatureFromJson: typeof validatorSignatureFromJson;
-declare const index$h_verdictFromJson: typeof verdictFromJson;
-declare const index$h_workExecResultFromJson: typeof workExecResultFromJson;
-declare const index$h_workPackageSpecFromJson: typeof workPackageSpecFromJson;
-declare const index$h_workRefineLoadFromJson: typeof workRefineLoadFromJson;
-declare const index$h_workReportFromJson: typeof workReportFromJson;
-declare const index$h_workResultFromJson: typeof workResultFromJson;
-declare namespace index$h {
-  export { index$h_bandersnatchVrfSignature as bandersnatchVrfSignature, index$h_blockFromJson as blockFromJson, index$h_culpritFromJson as culpritFromJson, index$h_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$h_epochMark as epochMark, index$h_faultFromJson as faultFromJson, index$h_fromJson as fromJson, index$h_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$h_getAvailabilityAssuranceFromJson as getAvailabilityAssuranceFromJson, index$h_getExtrinsicFromJson as getExtrinsicFromJson, index$h_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$h_headerFromJson as headerFromJson, index$h_judgementFromJson as judgementFromJson, index$h_preimageFromJson as preimageFromJson, index$h_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$h_refineContextFromJson as refineContextFromJson, index$h_reportGuaranteeFromJson as reportGuaranteeFromJson, index$h_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$h_ticket as ticket, index$h_ticketEnvelopeFromJson as ticketEnvelopeFromJson, index$h_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$h_validatorKeysFromJson as validatorKeysFromJson, index$h_validatorSignatureFromJson as validatorSignatureFromJson, index$h_verdictFromJson as verdictFromJson, index$h_workExecResultFromJson as workExecResultFromJson, index$h_workPackageSpecFromJson as workPackageSpecFromJson, index$h_workRefineLoadFromJson as workRefineLoadFromJson, index$h_workReportFromJson as workReportFromJson, index$h_workResultFromJson as workResultFromJson };
-  export type { index$h_CamelToSnake as CamelToSnake, index$h_JsonCulprit as JsonCulprit, index$h_JsonEpochMarker as JsonEpochMarker, index$h_JsonFault as JsonFault, index$h_JsonHeader as JsonHeader, index$h_JsonJudgement as JsonJudgement, index$h_JsonObject as JsonObject, index$h_JsonRefineContext as JsonRefineContext, index$h_JsonReportGuarantee as JsonReportGuarantee, index$h_JsonVerdict as JsonVerdict, index$h_JsonWorkExecResult as JsonWorkExecResult, index$h_JsonWorkRefineLoad as JsonWorkRefineLoad, index$h_JsonWorkReport as JsonWorkReport, index$h_JsonWorkResult as JsonWorkResult };
+type index$j_CamelToSnake<S extends string> = CamelToSnake<S>;
+type index$j_JsonCulprit = JsonCulprit;
+type index$j_JsonEpochMarker = JsonEpochMarker;
+type index$j_JsonFault = JsonFault;
+type index$j_JsonHeader = JsonHeader;
+type index$j_JsonJudgement = JsonJudgement;
+type index$j_JsonObject<T> = JsonObject<T>;
+type index$j_JsonRefineContext = JsonRefineContext;
+type index$j_JsonReportGuarantee = JsonReportGuarantee;
+type index$j_JsonVerdict = JsonVerdict;
+type index$j_JsonWorkExecResult = JsonWorkExecResult;
+type index$j_JsonWorkRefineLoad = JsonWorkRefineLoad;
+type index$j_JsonWorkReport = JsonWorkReport;
+type index$j_JsonWorkResult = JsonWorkResult;
+declare const index$j_bandersnatchVrfSignature: typeof bandersnatchVrfSignature;
+declare const index$j_blockFromJson: typeof blockFromJson;
+declare const index$j_culpritFromJson: typeof culpritFromJson;
+declare const index$j_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
+declare const index$j_epochMark: typeof epochMark;
+declare const index$j_faultFromJson: typeof faultFromJson;
+import index$j_fromJson = fromJson;
+declare const index$j_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
+declare const index$j_getAvailabilityAssuranceFromJson: typeof getAvailabilityAssuranceFromJson;
+declare const index$j_getExtrinsicFromJson: typeof getExtrinsicFromJson;
+declare const index$j_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
+declare const index$j_headerFromJson: typeof headerFromJson;
+declare const index$j_judgementFromJson: typeof judgementFromJson;
+declare const index$j_preimageFromJson: typeof preimageFromJson;
+declare const index$j_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
+declare const index$j_refineContextFromJson: typeof refineContextFromJson;
+declare const index$j_reportGuaranteeFromJson: typeof reportGuaranteeFromJson;
+declare const index$j_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
+declare const index$j_ticket: typeof ticket;
+declare const index$j_ticketEnvelopeFromJson: typeof ticketEnvelopeFromJson;
+declare const index$j_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
+declare const index$j_validatorKeysFromJson: typeof validatorKeysFromJson;
+declare const index$j_validatorSignatureFromJson: typeof validatorSignatureFromJson;
+declare const index$j_verdictFromJson: typeof verdictFromJson;
+declare const index$j_workExecResultFromJson: typeof workExecResultFromJson;
+declare const index$j_workPackageSpecFromJson: typeof workPackageSpecFromJson;
+declare const index$j_workRefineLoadFromJson: typeof workRefineLoadFromJson;
+declare const index$j_workReportFromJson: typeof workReportFromJson;
+declare const index$j_workResultFromJson: typeof workResultFromJson;
+declare namespace index$j {
+  export { index$j_bandersnatchVrfSignature as bandersnatchVrfSignature, index$j_blockFromJson as blockFromJson, index$j_culpritFromJson as culpritFromJson, index$j_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$j_epochMark as epochMark, index$j_faultFromJson as faultFromJson, index$j_fromJson as fromJson, index$j_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$j_getAvailabilityAssuranceFromJson as getAvailabilityAssuranceFromJson, index$j_getExtrinsicFromJson as getExtrinsicFromJson, index$j_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$j_headerFromJson as headerFromJson, index$j_judgementFromJson as judgementFromJson, index$j_preimageFromJson as preimageFromJson, index$j_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$j_refineContextFromJson as refineContextFromJson, index$j_reportGuaranteeFromJson as reportGuaranteeFromJson, index$j_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$j_ticket as ticket, index$j_ticketEnvelopeFromJson as ticketEnvelopeFromJson, index$j_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$j_validatorKeysFromJson as validatorKeysFromJson, index$j_validatorSignatureFromJson as validatorSignatureFromJson, index$j_verdictFromJson as verdictFromJson, index$j_workExecResultFromJson as workExecResultFromJson, index$j_workPackageSpecFromJson as workPackageSpecFromJson, index$j_workRefineLoadFromJson as workRefineLoadFromJson, index$j_workReportFromJson as workReportFromJson, index$j_workResultFromJson as workResultFromJson };
+  export type { index$j_CamelToSnake as CamelToSnake, index$j_JsonCulprit as JsonCulprit, index$j_JsonEpochMarker as JsonEpochMarker, index$j_JsonFault as JsonFault, index$j_JsonHeader as JsonHeader, index$j_JsonJudgement as JsonJudgement, index$j_JsonObject as JsonObject, index$j_JsonRefineContext as JsonRefineContext, index$j_JsonReportGuarantee as JsonReportGuarantee, index$j_JsonVerdict as JsonVerdict, index$j_JsonWorkExecResult as JsonWorkExecResult, index$j_JsonWorkRefineLoad as JsonWorkRefineLoad, index$j_JsonWorkReport as JsonWorkReport, index$j_JsonWorkResult as JsonWorkResult };
 }
 
 declare function parseBootnode(v: string): Bootnode {
@@ -8046,16 +8081,16 @@ declare class Logger {
   }
 }
 
-type index$g_Level = Level;
-declare const index$g_Level: typeof Level;
-type index$g_Logger = Logger;
-declare const index$g_Logger: typeof Logger;
-declare const index$g_parseLoggerOptions: typeof parseLoggerOptions;
-declare namespace index$g {
+type index$i_Level = Level;
+declare const index$i_Level: typeof Level;
+type index$i_Logger = Logger;
+declare const index$i_Logger: typeof Logger;
+declare const index$i_parseLoggerOptions: typeof parseLoggerOptions;
+declare namespace index$i {
   export {
-    index$g_Level as Level,
-    index$g_Logger as Logger,
-    index$g_parseLoggerOptions as parseLoggerOptions,
+    index$i_Level as Level,
+    index$i_Logger as Logger,
+    index$i_parseLoggerOptions as parseLoggerOptions,
   };
 }
 
@@ -8078,7 +8113,7 @@ declare class AuthorshipOptions {
   ) {}
 }
 
-declare const logger$1 = Logger.new(import.meta.filename, "config");
+declare const logger$2 = Logger.new(import.meta.filename, "config");
 
 /** Development config. Will accept unsealed blocks for now. */
 declare const DEV_CONFIG = "dev";
@@ -8160,30 +8195,30 @@ declare function loadConfig(configPath: string): NodeConfiguration {
   }
 }
 
-declare const index$f_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
-declare const index$f_DEV_CONFIG: typeof DEV_CONFIG;
-type index$f_JipChainSpec = JipChainSpec;
-declare const index$f_JipChainSpec: typeof JipChainSpec;
-type index$f_KnownChainSpec = KnownChainSpec;
-declare const index$f_KnownChainSpec: typeof KnownChainSpec;
-declare const index$f_NODE_DEFAULTS: typeof NODE_DEFAULTS;
-type index$f_NodeConfiguration = NodeConfiguration;
-declare const index$f_NodeConfiguration: typeof NodeConfiguration;
-declare const index$f_knownChainSpecFromJson: typeof knownChainSpecFromJson;
-declare const index$f_loadConfig: typeof loadConfig;
-declare const index$f_parseBootnode: typeof parseBootnode;
-declare namespace index$f {
+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$f_DEFAULT_CONFIG as DEFAULT_CONFIG,
-    index$f_DEV_CONFIG as DEV_CONFIG,
-    index$f_JipChainSpec as JipChainSpec,
-    index$f_KnownChainSpec as KnownChainSpec,
-    index$f_NODE_DEFAULTS as NODE_DEFAULTS,
-    index$f_NodeConfiguration as NodeConfiguration,
-    index$f_knownChainSpecFromJson as knownChainSpecFromJson,
-    index$f_loadConfig as loadConfig,
-    logger$1 as logger,
-    index$f_parseBootnode as parseBootnode,
+    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,
   };
 }
 
@@ -8970,43 +9005,43 @@ declare const bitLookup = [
   [0b00000000, 8],
 ];
 
-type index$e_BranchNode = BranchNode;
-declare const index$e_BranchNode: typeof BranchNode;
-type index$e_InMemoryTrie = InMemoryTrie;
-declare const index$e_InMemoryTrie: typeof InMemoryTrie;
-type index$e_InputKey = InputKey;
-type index$e_LeafNode = LeafNode;
-declare const index$e_LeafNode: typeof LeafNode;
-type index$e_NodeType = NodeType;
-declare const index$e_NodeType: typeof NodeType;
-type index$e_NodesDb = NodesDb;
-declare const index$e_NodesDb: typeof NodesDb;
-declare const index$e_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
-declare const index$e_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
-type index$e_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
-type index$e_TraversedPath = TraversedPath;
-declare const index$e_TraversedPath: typeof TraversedPath;
-type index$e_TrieHasher = TrieHasher;
-type index$e_TrieNode = TrieNode;
-declare const index$e_TrieNode: typeof TrieNode;
-type index$e_TrieNodeHash = TrieNodeHash;
-type index$e_TruncatedStateKey = TruncatedStateKey;
-type index$e_ValueHash = ValueHash;
-type index$e_WriteableNodesDb = WriteableNodesDb;
-declare const index$e_WriteableNodesDb: typeof WriteableNodesDb;
-declare const index$e_bitLookup: typeof bitLookup;
-declare const index$e_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
-declare const index$e_findNodeToReplace: typeof findNodeToReplace;
-declare const index$e_findSharedPrefix: typeof findSharedPrefix;
-declare const index$e_getBit: typeof getBit;
-declare const index$e_leafComparator: typeof leafComparator;
-declare const index$e_parseInputKey: typeof parseInputKey;
-declare const index$e_trieInsert: typeof trieInsert;
-declare const index$e_trieStringify: typeof trieStringify;
-declare const index$e_zero: typeof zero;
-declare namespace index$e {
-  export { index$e_BranchNode as BranchNode, index$e_InMemoryTrie as InMemoryTrie, index$e_LeafNode as LeafNode, index$e_NodeType as NodeType, index$e_NodesDb as NodesDb, index$e_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$e_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$e_TraversedPath as TraversedPath, index$e_TrieNode as TrieNode, index$e_WriteableNodesDb as WriteableNodesDb, index$e_bitLookup as bitLookup, index$e_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$e_findNodeToReplace as findNodeToReplace, index$e_findSharedPrefix as findSharedPrefix, index$e_getBit as getBit, index$e_leafComparator as leafComparator, index$e_parseInputKey as parseInputKey, index$e_trieInsert as trieInsert, index$e_trieStringify as trieStringify, index$e_zero as zero };
-  export type { index$e_InputKey as InputKey, StateKey$1 as StateKey, index$e_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$e_TrieHasher as TrieHasher, index$e_TrieNodeHash as TrieNodeHash, index$e_TruncatedStateKey as TruncatedStateKey, index$e_ValueHash as ValueHash };
+type index$g_BranchNode = BranchNode;
+declare const index$g_BranchNode: typeof BranchNode;
+type index$g_InMemoryTrie = InMemoryTrie;
+declare const index$g_InMemoryTrie: typeof InMemoryTrie;
+type index$g_InputKey = InputKey;
+type index$g_LeafNode = LeafNode;
+declare const index$g_LeafNode: typeof LeafNode;
+type index$g_NodeType = NodeType;
+declare const index$g_NodeType: typeof NodeType;
+type index$g_NodesDb = NodesDb;
+declare const index$g_NodesDb: typeof NodesDb;
+declare const index$g_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
+declare const index$g_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
+type index$g_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
+type index$g_TraversedPath = TraversedPath;
+declare const index$g_TraversedPath: typeof TraversedPath;
+type index$g_TrieHasher = TrieHasher;
+type index$g_TrieNode = TrieNode;
+declare const index$g_TrieNode: typeof TrieNode;
+type index$g_TrieNodeHash = TrieNodeHash;
+type index$g_TruncatedStateKey = TruncatedStateKey;
+type index$g_ValueHash = ValueHash;
+type index$g_WriteableNodesDb = WriteableNodesDb;
+declare const index$g_WriteableNodesDb: typeof WriteableNodesDb;
+declare const index$g_bitLookup: typeof bitLookup;
+declare const index$g_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
+declare const index$g_findNodeToReplace: typeof findNodeToReplace;
+declare const index$g_findSharedPrefix: typeof findSharedPrefix;
+declare const index$g_getBit: typeof getBit;
+declare const index$g_leafComparator: typeof leafComparator;
+declare const index$g_parseInputKey: typeof parseInputKey;
+declare const index$g_trieInsert: typeof trieInsert;
+declare const index$g_trieStringify: typeof trieStringify;
+declare const index$g_zero: typeof zero;
+declare namespace index$g {
+  export { index$g_BranchNode as BranchNode, index$g_InMemoryTrie as InMemoryTrie, index$g_LeafNode as LeafNode, index$g_NodeType as NodeType, index$g_NodesDb as NodesDb, index$g_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$g_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$g_TraversedPath as TraversedPath, index$g_TrieNode as TrieNode, index$g_WriteableNodesDb as WriteableNodesDb, index$g_bitLookup as bitLookup, index$g_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$g_findNodeToReplace as findNodeToReplace, index$g_findSharedPrefix as findSharedPrefix, index$g_getBit as getBit, index$g_leafComparator as leafComparator, index$g_parseInputKey as parseInputKey, index$g_trieInsert as trieInsert, index$g_trieStringify as trieStringify, index$g_zero as zero };
+  export type { index$g_InputKey as InputKey, StateKey$1 as StateKey, index$g_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$g_TrieHasher as TrieHasher, index$g_TrieNodeHash as TrieNodeHash, index$g_TruncatedStateKey as TruncatedStateKey, index$g_ValueHash as ValueHash };
 }
 
 /**
@@ -9448,16 +9483,16 @@ declare class Mountain<H extends OpaqueHash> {
   }
 }
 
-type index$d_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$d_MerkleMountainRange: typeof MerkleMountainRange;
-type index$d_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$d_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-type index$d_Mountain<H extends OpaqueHash> = Mountain<H>;
-declare const index$d_Mountain: typeof Mountain;
-declare const index$d_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
-declare namespace index$d {
-  export { index$d_MerkleMountainRange as MerkleMountainRange, index$d_Mountain as Mountain, index$d_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
-  export type { index$d_MmrHasher as MmrHasher, index$d_MmrPeaks as MmrPeaks };
+type index$f_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const index$f_MerkleMountainRange: typeof MerkleMountainRange;
+type index$f_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type index$f_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+type index$f_Mountain<H extends OpaqueHash> = Mountain<H>;
+declare const index$f_Mountain: typeof Mountain;
+declare const index$f_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
+declare namespace index$f {
+  export { index$f_MerkleMountainRange as MerkleMountainRange, index$f_Mountain as Mountain, index$f_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
+  export type { index$f_MmrHasher as MmrHasher, index$f_MmrPeaks as MmrPeaks };
 }
 
 /**
@@ -11155,103 +11190,103 @@ type FieldNames<T> = {
   [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-type index$c_AccumulationOutput = AccumulationOutput;
-declare const index$c_AccumulationOutput: typeof AccumulationOutput;
-type index$c_AutoAccumulate = AutoAccumulate;
-declare const index$c_AutoAccumulate: typeof AutoAccumulate;
-type index$c_AvailabilityAssignment = AvailabilityAssignment;
-declare const index$c_AvailabilityAssignment: typeof AvailabilityAssignment;
-declare const index$c_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
-type index$c_BlockState = BlockState;
-declare const index$c_BlockState: typeof BlockState;
-type index$c_BlocksState = BlocksState;
-type index$c_CoreStatistics = CoreStatistics;
-declare const index$c_CoreStatistics: typeof CoreStatistics;
-type index$c_DisputesRecords = DisputesRecords;
-declare const index$c_DisputesRecords: typeof DisputesRecords;
-declare const index$c_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
-declare const index$c_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
-type index$c_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
-type index$c_EnumerableState = EnumerableState;
-type index$c_FieldNames<T> = FieldNames<T>;
-type index$c_InMemoryService = InMemoryService;
-declare const index$c_InMemoryService: typeof InMemoryService;
-type index$c_InMemoryState = InMemoryState;
-declare const index$c_InMemoryState: typeof InMemoryState;
-type index$c_InMemoryStateFields = InMemoryStateFields;
-type index$c_LookupHistoryItem = LookupHistoryItem;
-declare const index$c_LookupHistoryItem: typeof LookupHistoryItem;
-type index$c_LookupHistorySlots = LookupHistorySlots;
-declare const index$c_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
-type index$c_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
-type index$c_PerCore<T> = PerCore<T>;
-type index$c_PreimageItem = PreimageItem;
-declare const index$c_PreimageItem: typeof PreimageItem;
-type index$c_PrivilegedServices = PrivilegedServices;
-declare const index$c_PrivilegedServices: typeof PrivilegedServices;
-type index$c_RecentBlocks = RecentBlocks;
-declare const index$c_RecentBlocks: typeof RecentBlocks;
-type index$c_RecentBlocksHistory = RecentBlocksHistory;
-declare const index$c_RecentBlocksHistory: typeof RecentBlocksHistory;
-type index$c_SafroleData = SafroleData;
-declare const index$c_SafroleData: typeof SafroleData;
-type index$c_SafroleSealingKeys = SafroleSealingKeys;
-type index$c_SafroleSealingKeysData = SafroleSealingKeysData;
-declare const index$c_SafroleSealingKeysData: typeof SafroleSealingKeysData;
-type index$c_SafroleSealingKeysKind = SafroleSealingKeysKind;
-declare const index$c_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
-type index$c_Service = Service;
-type index$c_ServiceAccountInfo = ServiceAccountInfo;
-declare const index$c_ServiceAccountInfo: typeof ServiceAccountInfo;
-type index$c_ServiceData = ServiceData;
-type index$c_ServiceEntries = ServiceEntries;
-type index$c_ServiceStatistics = ServiceStatistics;
-declare const index$c_ServiceStatistics: typeof ServiceStatistics;
-type index$c_ServicesUpdate = ServicesUpdate;
-type index$c_State = State;
-type index$c_StatisticsData = StatisticsData;
-declare const index$c_StatisticsData: typeof StatisticsData;
-type index$c_StorageItem = StorageItem;
-declare const index$c_StorageItem: typeof StorageItem;
-type index$c_StorageKey = StorageKey;
-type index$c_UpdateError = UpdateError;
-declare const index$c_UpdateError: typeof UpdateError;
-type index$c_UpdatePreimage = UpdatePreimage;
-declare const index$c_UpdatePreimage: typeof UpdatePreimage;
-type index$c_UpdatePreimageKind = UpdatePreimageKind;
-declare const index$c_UpdatePreimageKind: typeof UpdatePreimageKind;
-type index$c_UpdateService = UpdateService;
-declare const index$c_UpdateService: typeof UpdateService;
-type index$c_UpdateServiceKind = UpdateServiceKind;
-declare const index$c_UpdateServiceKind: typeof UpdateServiceKind;
-type index$c_UpdateStorage = UpdateStorage;
-declare const index$c_UpdateStorage: typeof UpdateStorage;
-type index$c_UpdateStorageKind = UpdateStorageKind;
-declare const index$c_UpdateStorageKind: typeof UpdateStorageKind;
-type index$c_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
-type index$c_ValidatorData = ValidatorData;
-declare const index$c_ValidatorData: typeof ValidatorData;
-type index$c_ValidatorStatistics = ValidatorStatistics;
-declare const index$c_ValidatorStatistics: typeof ValidatorStatistics;
-declare const index$c_accumulationOutputComparator: typeof accumulationOutputComparator;
-declare const index$c_codecBandersnatchKey: typeof codecBandersnatchKey;
-declare const index$c_codecPerCore: typeof codecPerCore;
-declare const index$c_codecServiceId: typeof codecServiceId;
-declare const index$c_codecVarGas: typeof codecVarGas;
-declare const index$c_codecVarU16: typeof codecVarU16;
-declare const index$c_codecWithHash: typeof codecWithHash;
-declare const index$c_hashComparator: typeof hashComparator;
-declare const index$c_ignoreValueWithDefault: typeof ignoreValueWithDefault;
-declare const index$c_serviceDataCodec: typeof serviceDataCodec;
-declare const index$c_serviceEntriesCodec: typeof serviceEntriesCodec;
-declare const index$c_sortedSetCodec: typeof sortedSetCodec;
-declare const index$c_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
-declare const index$c_tryAsPerCore: typeof tryAsPerCore;
-declare const index$c_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
-declare const index$c_zeroSizeHint: typeof zeroSizeHint;
-declare namespace index$c {
-  export { index$c_AccumulationOutput as AccumulationOutput, index$c_AutoAccumulate as AutoAccumulate, index$c_AvailabilityAssignment as AvailabilityAssignment, index$c_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$c_BlockState as BlockState, index$c_CoreStatistics as CoreStatistics, index$c_DisputesRecords as DisputesRecords, index$c_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$c_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$c_InMemoryService as InMemoryService, index$c_InMemoryState as InMemoryState, index$c_LookupHistoryItem as LookupHistoryItem, index$c_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$c_PreimageItem as PreimageItem, index$c_PrivilegedServices as PrivilegedServices, index$c_RecentBlocks as RecentBlocks, index$c_RecentBlocksHistory as RecentBlocksHistory, index$c_SafroleData as SafroleData, index$c_SafroleSealingKeysData as SafroleSealingKeysData, index$c_SafroleSealingKeysKind as SafroleSealingKeysKind, index$c_ServiceAccountInfo as ServiceAccountInfo, index$c_ServiceStatistics as ServiceStatistics, index$c_StatisticsData as StatisticsData, index$c_StorageItem as StorageItem, index$c_UpdateError as UpdateError, index$c_UpdatePreimage as UpdatePreimage, index$c_UpdatePreimageKind as UpdatePreimageKind, index$c_UpdateService as UpdateService, index$c_UpdateServiceKind as UpdateServiceKind, index$c_UpdateStorage as UpdateStorage, index$c_UpdateStorageKind as UpdateStorageKind, index$c_ValidatorData as ValidatorData, index$c_ValidatorStatistics as ValidatorStatistics, index$c_accumulationOutputComparator as accumulationOutputComparator, index$c_codecBandersnatchKey as codecBandersnatchKey, index$c_codecPerCore as codecPerCore, index$c_codecServiceId as codecServiceId, index$c_codecVarGas as codecVarGas, index$c_codecVarU16 as codecVarU16, index$c_codecWithHash as codecWithHash, index$c_hashComparator as hashComparator, index$c_ignoreValueWithDefault as ignoreValueWithDefault, index$c_serviceDataCodec as serviceDataCodec, index$c_serviceEntriesCodec as serviceEntriesCodec, index$c_sortedSetCodec as sortedSetCodec, index$c_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$c_tryAsPerCore as tryAsPerCore, index$c_workReportsSortedSetCodec as workReportsSortedSetCodec, index$c_zeroSizeHint as zeroSizeHint };
-  export type { index$c_BlocksState as BlocksState, index$c_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$c_EnumerableState as EnumerableState, index$c_FieldNames as FieldNames, index$c_InMemoryStateFields as InMemoryStateFields, index$c_LookupHistorySlots as LookupHistorySlots, index$c_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$c_PerCore as PerCore, index$c_SafroleSealingKeys as SafroleSealingKeys, index$c_Service as Service, index$c_ServiceData as ServiceData, index$c_ServiceEntries as ServiceEntries, index$c_ServicesUpdate as ServicesUpdate, index$c_State as State, index$c_StorageKey as StorageKey, index$c_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
+type index$e_AccumulationOutput = AccumulationOutput;
+declare const index$e_AccumulationOutput: typeof AccumulationOutput;
+type index$e_AutoAccumulate = AutoAccumulate;
+declare const index$e_AutoAccumulate: typeof AutoAccumulate;
+type index$e_AvailabilityAssignment = AvailabilityAssignment;
+declare const index$e_AvailabilityAssignment: typeof AvailabilityAssignment;
+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;
+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_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_RecentBlocksHistory = RecentBlocksHistory;
+declare const index$e_RecentBlocksHistory: typeof RecentBlocksHistory;
+type index$e_SafroleData = SafroleData;
+declare const index$e_SafroleData: typeof SafroleData;
+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_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_StatisticsData = StatisticsData;
+declare const index$e_StatisticsData: typeof StatisticsData;
+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_ValidatorStatistics = ValidatorStatistics;
+declare const index$e_ValidatorStatistics: typeof ValidatorStatistics;
+declare const index$e_accumulationOutputComparator: typeof accumulationOutputComparator;
+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_codecWithHash: typeof codecWithHash;
+declare const index$e_hashComparator: typeof hashComparator;
+declare const index$e_ignoreValueWithDefault: typeof ignoreValueWithDefault;
+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_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_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_RecentBlocksHistory as RecentBlocksHistory, 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_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_codecWithHash as codecWithHash, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, 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_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export type { 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_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -12189,44 +12224,44 @@ declare function loadState(spec: ChainSpec, entries: Iterable<[StateKey | Trunca
  *        hashmap of `key -> value` entries.
  */
 
-declare const index$b_EMPTY_BLOB: typeof EMPTY_BLOB;
-type index$b_EncodeFun = EncodeFun;
-type index$b_KeyAndCodec<T> = KeyAndCodec<T>;
-type index$b_SerializedService = SerializedService;
-declare const index$b_SerializedService: typeof SerializedService;
-type index$b_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
-declare const index$b_SerializedState: typeof SerializedState;
-type index$b_SerializedStateBackend = SerializedStateBackend;
-type index$b_StateCodec<T> = StateCodec<T>;
-type index$b_StateEntries = StateEntries;
-declare const index$b_StateEntries: typeof StateEntries;
-type index$b_StateEntryUpdate = StateEntryUpdate;
-type index$b_StateEntryUpdateAction = StateEntryUpdateAction;
-declare const index$b_StateEntryUpdateAction: typeof StateEntryUpdateAction;
-type index$b_StateKey = StateKey;
-type index$b_StateKeyIdx = StateKeyIdx;
-declare const index$b_StateKeyIdx: typeof StateKeyIdx;
-declare const index$b_TYPICAL_STATE_ITEMS: typeof TYPICAL_STATE_ITEMS;
-declare const index$b_TYPICAL_STATE_ITEM_LEN: typeof TYPICAL_STATE_ITEM_LEN;
-declare const index$b_U32_BYTES: typeof U32_BYTES;
-declare const index$b_binaryMerkleization: typeof binaryMerkleization;
-declare const index$b_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
-declare const index$b_dumpCodec: typeof dumpCodec;
-declare const index$b_getSafroleData: typeof getSafroleData;
-declare const index$b_legacyServiceNested: typeof legacyServiceNested;
-declare const index$b_loadState: typeof loadState;
-import index$b_serialize = serialize;
-declare const index$b_serializeBasicKeys: typeof serializeBasicKeys;
-declare const index$b_serializePreimages: typeof serializePreimages;
-declare const index$b_serializeRemovedServices: typeof serializeRemovedServices;
-declare const index$b_serializeServiceUpdates: typeof serializeServiceUpdates;
-declare const index$b_serializeStateUpdate: typeof serializeStateUpdate;
-declare const index$b_serializeStorage: typeof serializeStorage;
-declare const index$b_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
-import index$b_stateKeys = stateKeys;
-declare namespace index$b {
-  export { index$b_EMPTY_BLOB as EMPTY_BLOB, index$b_SerializedService as SerializedService, index$b_SerializedState as SerializedState, index$b_StateEntries as StateEntries, index$b_StateEntryUpdateAction as StateEntryUpdateAction, index$b_StateKeyIdx as StateKeyIdx, index$b_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$b_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$b_U32_BYTES as U32_BYTES, index$b_binaryMerkleization as binaryMerkleization, index$b_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$b_dumpCodec as dumpCodec, index$b_getSafroleData as getSafroleData, index$b_legacyServiceNested as legacyServiceNested, index$b_loadState as loadState, index$b_serialize as serialize, index$b_serializeBasicKeys as serializeBasicKeys, index$b_serializePreimages as serializePreimages, index$b_serializeRemovedServices as serializeRemovedServices, index$b_serializeServiceUpdates as serializeServiceUpdates, index$b_serializeStateUpdate as serializeStateUpdate, index$b_serializeStorage as serializeStorage, index$b_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$b_stateKeys as stateKeys };
-  export type { index$b_EncodeFun as EncodeFun, index$b_KeyAndCodec as KeyAndCodec, index$b_SerializedStateBackend as SerializedStateBackend, index$b_StateCodec as StateCodec, index$b_StateEntryUpdate as StateEntryUpdate, index$b_StateKey as StateKey };
+declare const index$d_EMPTY_BLOB: typeof EMPTY_BLOB;
+type index$d_EncodeFun = EncodeFun;
+type index$d_KeyAndCodec<T> = KeyAndCodec<T>;
+type index$d_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_StateCodec<T> = StateCodec<T>;
+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_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_SerializedStateBackend as SerializedStateBackend, index$d_StateCodec as StateCodec, index$d_StateEntryUpdate as StateEntryUpdate, index$d_StateKey as StateKey };
 }
 
 /** Error during `LeafDb` creation. */
@@ -12434,25 +12469,25 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   }
 }
 
-type index$a_BlocksDb = BlocksDb;
-type index$a_InMemoryBlocks = InMemoryBlocks;
-declare const index$a_InMemoryBlocks: typeof InMemoryBlocks;
-type index$a_InMemoryStates = InMemoryStates;
-declare const index$a_InMemoryStates: typeof InMemoryStates;
-type index$a_LeafDb = LeafDb;
-declare const index$a_LeafDb: typeof LeafDb;
-type index$a_LeafDbError = LeafDbError;
-declare const index$a_LeafDbError: typeof LeafDbError;
-type index$a_Lookup = Lookup;
-type index$a_LookupKind = LookupKind;
-declare const index$a_LookupKind: typeof LookupKind;
-type index$a_StateUpdateError = StateUpdateError;
-declare const index$a_StateUpdateError: typeof StateUpdateError;
-type index$a_StatesDb<T extends State = State> = StatesDb<T>;
-type index$a_ValuesDb = ValuesDb;
-declare namespace index$a {
-  export { index$a_InMemoryBlocks as InMemoryBlocks, index$a_InMemoryStates as InMemoryStates, index$a_LeafDb as LeafDb, index$a_LeafDbError as LeafDbError, index$a_LookupKind as LookupKind, index$a_StateUpdateError as StateUpdateError };
-  export type { index$a_BlocksDb as BlocksDb, index$a_Lookup as Lookup, index$a_StatesDb as StatesDb, index$a_ValuesDb as ValuesDb };
+type index$c_BlocksDb = BlocksDb;
+type index$c_InMemoryBlocks = InMemoryBlocks;
+declare const index$c_InMemoryBlocks: typeof InMemoryBlocks;
+type index$c_InMemoryStates = InMemoryStates;
+declare const index$c_InMemoryStates: typeof InMemoryStates;
+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_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 namespace index$c {
+  export { index$c_InMemoryBlocks as InMemoryBlocks, 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 };
+  export type { index$c_BlocksDb as BlocksDb, index$c_Lookup as Lookup, index$c_StatesDb as StatesDb, index$c_ValuesDb as ValuesDb };
 }
 
 /**
@@ -12874,31 +12909,572 @@ declare const initEc = async () => {
   await init.reedSolomon();
 };
 
-declare const index$9_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
-declare const index$9_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
-type index$9_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
-type index$9_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
-type index$9_PIECE_SIZE = PIECE_SIZE;
-declare const index$9_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
-type index$9_POINT_LENGTH = POINT_LENGTH;
-declare const index$9_checkConsistency: typeof checkConsistency;
-declare const index$9_chunkingFunction: typeof chunkingFunction;
-declare const index$9_chunksToShards: typeof chunksToShards;
-declare const index$9_decodeData: typeof decodeData;
-declare const index$9_decodeDataAndTrim: typeof decodeDataAndTrim;
-declare const index$9_decodePiece: typeof decodePiece;
-declare const index$9_encodePoints: typeof encodePoints;
-declare const index$9_initEc: typeof initEc;
-declare const index$9_join: typeof join;
-declare const index$9_lace: typeof lace;
-declare const index$9_padAndEncodeData: typeof padAndEncodeData;
-declare const index$9_shardsToChunks: typeof shardsToChunks;
-declare const index$9_split: typeof split;
-declare const index$9_transpose: typeof transpose;
-declare const index$9_unzip: typeof unzip;
+declare const index$b_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
+declare const index$b_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
+type index$b_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
+type index$b_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
+type index$b_PIECE_SIZE = PIECE_SIZE;
+declare const index$b_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
+type index$b_POINT_LENGTH = POINT_LENGTH;
+declare const index$b_checkConsistency: typeof checkConsistency;
+declare const index$b_chunkingFunction: typeof chunkingFunction;
+declare const index$b_chunksToShards: typeof chunksToShards;
+declare const index$b_decodeData: typeof decodeData;
+declare const index$b_decodeDataAndTrim: typeof decodeDataAndTrim;
+declare const index$b_decodePiece: typeof decodePiece;
+declare const index$b_encodePoints: typeof encodePoints;
+declare const index$b_initEc: typeof initEc;
+declare const index$b_join: typeof join;
+declare const index$b_lace: typeof lace;
+declare const index$b_padAndEncodeData: typeof padAndEncodeData;
+declare const index$b_shardsToChunks: typeof shardsToChunks;
+declare const index$b_split: typeof split;
+declare const index$b_transpose: typeof transpose;
+declare const index$b_unzip: typeof unzip;
+declare namespace index$b {
+  export { index$b_HALF_POINT_SIZE as HALF_POINT_SIZE, index$b_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$b_POINT_ALIGNMENT as POINT_ALIGNMENT, index$b_checkConsistency as checkConsistency, index$b_chunkingFunction as chunkingFunction, index$b_chunksToShards as chunksToShards, index$b_decodeData as decodeData, index$b_decodeDataAndTrim as decodeDataAndTrim, index$b_decodePiece as decodePiece, index$b_encodePoints as encodePoints, index$b_initEc as initEc, index$b_join as join, index$b_lace as lace, index$b_padAndEncodeData as padAndEncodeData, index$b_shardsToChunks as shardsToChunks, index$b_split as split, index$b_transpose as transpose, index$b_unzip as unzip };
+  export type { index$b_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$b_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$b_PIECE_SIZE as PIECE_SIZE, index$b_POINT_LENGTH as POINT_LENGTH };
+}
+
+/** A per-client handler of incoming socket messages. */
+interface IpcHandler {
+  /** New data on the socket received. */
+  onSocketMessage(msg: Uint8Array): Promise<void>;
+
+  /** Socket closed or errored. */
+  onClose(reason: { error?: Error }): void;
+}
+
+/** Sending data abstraction on a socket. */
+interface IpcSender {
+  /** Write given data to the outgoing socket. */
+  send(data: BytesBlob): void;
+
+  /** Close the socket. */
+  close(): void;
+}
+
+/**
+ * Version ::= SEQUENCE {
+ *     major INTEGER (0..255),
+ *     minor INTEGER (0..255),
+ *     patch INTEGER (0..255)
+ * }
+ */
+declare class Version extends WithDebug {
+  static Codec = codec.Class(Version, {
+    major: codec.u8,
+    minor: codec.u8,
+    patch: codec.u8,
+  });
+
+  static tryFromString(str: string): Version {
+    const parse = (v: string) => tryAsU8(Number(v));
+    try {
+      const [major, minor, patch] = str.trim().split(".").map(parse);
+
+      return Version.create({
+        major,
+        minor,
+        patch,
+      });
+    } catch (e) {
+      throw new Error(`Unable to parse ${str} as Version: ${e}`);
+    }
+  }
+
+  static create({ major, minor, patch }: CodecRecord<Version>) {
+    return new Version(major, minor, patch);
+  }
+
+  private constructor(
+    public readonly major: U8,
+    public readonly minor: U8,
+    public readonly patch: U8,
+  ) {
+    super();
+  }
+}
+
+/**
+ * Fuzzer Protocol V1
+ * Reference: https://github.com/davxy/jam-conformance/blob/main/fuzz-proto/fuzz.asn
+ */
+// Feature bit constants
+declare enum Features {
+  Ancestry = 1, // 2^0
+  Fork = 2, // 2^1
+  Reserved = 2147483648, // 2^31
+}
+
+/**
+ * PeerInfo ::= SEQUENCE {
+ *     fuzz-version U8,
+ *     features     Features,
+ *     jam-version  Version,
+ *     app-version  Version,
+ *     name         UTF8String
+ * }
+ */
+declare class PeerInfo extends WithDebug {
+  static Codec = codec.Class(PeerInfo, {
+    fuzzVersion: codec.u8,
+    features: codec.u32,
+    jamVersion: Version.Codec,
+    appVersion: Version.Codec,
+    name: codec.string,
+  });
+
+  static create({ fuzzVersion, features, appVersion, jamVersion, name }: CodecRecord<PeerInfo>) {
+    return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
+  }
+
+  private constructor(
+    public readonly fuzzVersion: U8,
+    public readonly features: U32,
+    public readonly jamVersion: Version,
+    public readonly appVersion: Version,
+    public readonly name: string,
+  ) {
+    super();
+  }
+}
+
+/**
+ * AncestryItem ::= SEQUENCE {
+ *     slot TimeSlot,
+ *     header-hash HeaderHash
+ * }
+ */
+declare class AncestryItem extends WithDebug {
+  static Codec = codec.Class(AncestryItem, {
+    slot: codec.u32.asOpaque<TimeSlot>(),
+    headerHash: codec.bytes(HASH_SIZE).asOpaque<HeaderHash>(),
+  });
+
+  static create({ slot, headerHash }: CodecRecord<AncestryItem>) {
+    return new AncestryItem(slot, headerHash);
+  }
+
+  private constructor(
+    public readonly slot: TimeSlot,
+    public readonly headerHash: HeaderHash,
+  ) {
+    super();
+  }
+}
+
+/**
+ * KeyValue ::= SEQUENCE {
+ *     key     TrieKey,
+ *     value   OCTET STRING
+ * }
+ */
+declare class KeyValue extends WithDebug {
+  static Codec = codec.Class(KeyValue, {
+    key: codec.bytes(TRUNCATED_HASH_SIZE),
+    value: codec.blob,
+  });
+
+  static create({ key, value }: CodecRecord<KeyValue>) {
+    return new KeyValue(key, value);
+  }
+
+  private constructor(
+    public readonly key: TruncatedHash,
+    public readonly value: BytesBlob,
+  ) {
+    super();
+  }
+}
+
+/** State ::= SEQUENCE OF KeyValue */
+declare const stateCodec = codec.sequenceVarLen(KeyValue.Codec);
+
+/**
+ * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
+ * Empty when `feature-ancestry` is not supported by both parties
+ */
+declare const ancestryCodec = codec.sequenceVarLen(AncestryItem.Codec, {
+  minLength: 0,
+  maxLength: 24,
+});
+type Ancestry = AncestryItem[];
+
+/**
+ * Initialize ::= SEQUENCE {
+ *     header Header,
+ *     keyvals State,
+ *     ancestry Ancestry
+ * }
+ */
+declare class Initialize extends WithDebug {
+  static Codec = codec.Class(Initialize, {
+    header: Header.Codec,
+    keyvals: stateCodec,
+    ancestry: ancestryCodec,
+  });
+
+  static create({ header, keyvals, ancestry }: CodecRecord<Initialize>) {
+    return new Initialize(header, keyvals, ancestry);
+  }
+
+  private constructor(
+    public readonly header: Header,
+    public readonly keyvals: KeyValue[],
+    public readonly ancestry: Ancestry,
+  ) {
+    super();
+  }
+}
+
+/** GetState ::= HeaderHash */
+declare const getStateCodec = codec.bytes(HASH_SIZE).asOpaque<HeaderHash>();
+type GetState = HeaderHash;
+
+/** StateRoot ::= StateRootHash */
+declare const stateRootCodec = codec.bytes(HASH_SIZE).asOpaque<StateRootHash>();
+type StateRoot = StateRootHash;
+
+/** Error ::= UTF8String */
+declare class ErrorMessage extends WithDebug {
+  static Codec = codec.Class(ErrorMessage, {
+    message: codec.string,
+  });
+
+  static create({ message }: CodecRecord<ErrorMessage>): ErrorMessage {
+    return new ErrorMessage(message);
+  }
+
+  private constructor(public readonly message: string) {
+    super();
+  }
+}
+
+/** Message choice type tags */
+declare enum MessageType {
+  PeerInfo = 0,
+  Initialize = 1,
+  StateRoot = 2,
+  ImportBlock = 3,
+  GetState = 4,
+  State = 5,
+  Error = 255,
+}
+
+/** Message data union */
+type MessageData =
+  | { type: MessageType.PeerInfo; value: PeerInfo }
+  | { type: MessageType.Initialize; value: Initialize }
+  | { type: MessageType.StateRoot; value: StateRoot }
+  | { type: MessageType.ImportBlock; value: BlockView }
+  | { type: MessageType.GetState; value: GetState }
+  | { type: MessageType.State; value: KeyValue[] }
+  | { type: MessageType.Error; value: ErrorMessage };
+
+/**
+ * Message ::= CHOICE {
+ *     peer-info     [0] PeerInfo,
+ *     initialize    [1] Initialize,
+ *     state-root    [2] StateRoot,
+ *     import-block  [3] ImportBlock,
+ *     get-state     [4] GetState,
+ *     state         [5] State,
+ *     error         [255] Error
+ * }
+ */
+declare const messageCodec = codec.custom<MessageData>(
+  {
+    name: "Message",
+    sizeHint: { bytes: 1, isExact: false },
+  },
+  (e, msg) => {
+    e.i8(msg.type);
+    switch (msg.type) {
+      case MessageType.PeerInfo:
+        PeerInfo.Codec.encode(e, msg.value);
+        break;
+      case MessageType.Initialize:
+        Initialize.Codec.encode(e, msg.value);
+        break;
+      case MessageType.StateRoot:
+        stateRootCodec.encode(e, msg.value);
+        break;
+      case MessageType.ImportBlock:
+        Block.Codec.View.encode(e, msg.value);
+        break;
+      case MessageType.GetState:
+        getStateCodec.encode(e, msg.value);
+        break;
+      case MessageType.State:
+        stateCodec.encode(e, msg.value);
+        break;
+      case MessageType.Error:
+        ErrorMessage.Codec.encode(e, msg.value);
+        break;
+      default:
+        throw new Error(`Unknown message type: ${msg}`);
+    }
+  },
+  (d): MessageData => {
+    const type = d.u8();
+    switch (type) {
+      case MessageType.PeerInfo:
+        return { type: MessageType.PeerInfo, value: PeerInfo.Codec.decode(d) };
+      case MessageType.Initialize:
+        return { type: MessageType.Initialize, value: Initialize.Codec.decode(d) };
+      case MessageType.StateRoot:
+        return { type: MessageType.StateRoot, value: stateRootCodec.decode(d) };
+      case MessageType.ImportBlock:
+        return { type: MessageType.ImportBlock, value: Block.Codec.View.decode(d) };
+      case MessageType.GetState:
+        return { type: MessageType.GetState, value: getStateCodec.decode(d) };
+      case MessageType.State:
+        return { type: MessageType.State, value: stateCodec.decode(d) };
+      case MessageType.Error:
+        return { type: MessageType.Error, value: ErrorMessage.Codec.decode(d) };
+      default:
+        throw new Error(`Unknown message type: ${type}`);
+    }
+  },
+  (s) => {
+    const type = s.decoder.u8();
+    switch (type) {
+      case MessageType.PeerInfo:
+        PeerInfo.Codec.View.skip(s);
+        break;
+      case MessageType.Initialize:
+        Initialize.Codec.View.skip(s);
+        break;
+      case MessageType.StateRoot:
+        stateRootCodec.View.skip(s);
+        break;
+      case MessageType.ImportBlock:
+        Block.Codec.View.skip(s);
+        break;
+      case MessageType.GetState:
+        getStateCodec.View.skip(s);
+        break;
+      case MessageType.State:
+        stateCodec.View.skip(s);
+        break;
+      case MessageType.Error:
+        ErrorMessage.Codec.View.skip(s);
+        break;
+      default:
+        throw new Error(`Unknown message type: ${type}`);
+    }
+  },
+);
+
+type Message = MessageData;
+
+declare const logger$1 = Logger.new(import.meta.filename, "ext-ipc-fuzz-v1");
+
+/**
+ * Handler interface for v1 fuzzer protocol messages.
+ * https://github.com/davxy/jam-conformance/blob/main/fuzz-proto/fuzz-v1.asn
+ */
+interface FuzzMessageHandler {
+  /**
+   * Handshake and versioning exchange.
+   * Target waits to receive the fuzzer's PeerInfo message before sending its own.
+   */
+  getPeerInfo(value: PeerInfo): Promise<PeerInfo>;
+
+  /**
+   * Initialize or reset target state.
+   * Returns the state root of the initialized state.
+   */
+  initialize(header: Initialize): Promise<StateRootHash>;
+
+  /**
+   * Process block and return resulting state root.
+   * May return an Error if the block import fails.
+   */
+  importBlock(value: BlockView): Promise<Result$2<StateRootHash, ErrorMessage>>;
+
+  /** Retrieve posterior state associated to given header hash. */
+  getSerializedState(value: HeaderHash): Promise<KeyValue[]>;
+}
+
+declare class FuzzTarget implements IpcHandler {
+  private sessionFeatures = 0;
+
+  constructor(
+    public readonly msgHandler: FuzzMessageHandler,
+    public readonly sender: IpcSender,
+    public readonly spec: ChainSpec,
+  ) {}
+
+  async onSocketMessage(msg: Uint8Array): Promise<void> {
+    // attempt to decode the messsage
+    try {
+      const message = Decoder.decodeObject(messageCodec, msg, this.spec);
+      logger.log`[${message.type}] incoming message`;
+
+      await this.processAndRespond(message);
+    } catch (e) {
+      logger.error`Error while processing fuzz v1 message: ${e}`;
+      logger.error`${e}`;
+      if (e instanceof Error) {
+        logger.error`${e.stack ?? ""}`;
+      }
+      this.sender.close();
+    }
+  }
+
+  private async processAndRespond(message: MessageData): Promise<void> {
+    let response: Message | null = null;
+
+    switch (message.type) {
+      case MessageType.PeerInfo: {
+        // only support V1
+        if (message.value.fuzzVersion !== 1) {
+          logger.warn`Unsupported fuzzer protocol version: ${message.value.fuzzVersion}. Closing`;
+          this.sender.close();
+          return;
+        }
+
+        // Handle handshake
+        const ourPeerInfo = await this.msgHandler.getPeerInfo(message.value);
+
+        // Calculate session features (intersection of both peer features)
+        this.sessionFeatures = message.value.features & ourPeerInfo.features;
+
+        logger.info`Handshake completed. Shared features: 0b${this.sessionFeatures.toString(2)}`;
+        logger.log`Feature ancestry: ${(this.sessionFeatures & Features.Ancestry) !== 0}`;
+        logger.log`Feature fork: ${(this.sessionFeatures & Features.Fork) !== 0}`;
+
+        response = {
+          type: MessageType.PeerInfo,
+          value: ourPeerInfo,
+        };
+        break;
+      }
+
+      case MessageType.Initialize: {
+        const stateRoot = await this.msgHandler.initialize(message.value);
+        response = {
+          type: MessageType.StateRoot,
+          value: stateRoot,
+        };
+        break;
+      }
+
+      case MessageType.ImportBlock: {
+        const result = await this.msgHandler.importBlock(message.value);
+
+        if (result.isOk) {
+          response = {
+            type: MessageType.StateRoot,
+            value: result.ok,
+          };
+        } else {
+          response = {
+            type: MessageType.Error,
+            value: result.error,
+          };
+        }
+        break;
+      }
+
+      case MessageType.GetState: {
+        const state = await this.msgHandler.getSerializedState(message.value);
+        response = {
+          type: MessageType.State,
+          value: state,
+        };
+        break;
+      }
+
+      case MessageType.StateRoot: {
+        logger.log`--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`;
+        this.sender.close();
+        return;
+      }
+
+      case MessageType.State: {
+        logger.log`--> Received unexpected 'State' message from the fuzzer. Closing.`;
+        this.sender.close();
+        return;
+      }
+
+      case MessageType.Error: {
+        logger.log`--> Received unexpected 'Error' message from the fuzzer. Closing.`;
+        this.sender.close();
+        return;
+      }
+
+      default: {
+        logger.log`--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`;
+        this.sender.close();
+        try {
+          assertNever(message);
+        } catch {
+          return;
+        }
+      }
+    }
+
+    if (response !== null) {
+      logger.trace`<-- responding with: ${response.type}`;
+      const encoded = Encoder.encodeObject(messageCodec, response, this.spec);
+      this.sender.send(encoded);
+    } else {
+      logger.warn`<-- no response generated for: ${message.type}`;
+    }
+  }
+
+  onClose({ error }: { error?: Error }): void {
+    logger.log`Closing the v1 handler. Reason: ${error !== undefined ? error.message : "close"}.`;
+  }
+
+  /** Check if a specific feature is enabled in the session */
+  hasFeature(feature: number): boolean {
+    return (this.sessionFeatures & feature) !== 0;
+  }
+}
+
+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$9_IpcHandler = IpcHandler;
+type index$9_IpcSender = IpcSender;
 declare namespace index$9 {
-  export { index$9_HALF_POINT_SIZE as HALF_POINT_SIZE, index$9_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$9_POINT_ALIGNMENT as POINT_ALIGNMENT, index$9_checkConsistency as checkConsistency, index$9_chunkingFunction as chunkingFunction, index$9_chunksToShards as chunksToShards, index$9_decodeData as decodeData, index$9_decodeDataAndTrim as decodeDataAndTrim, index$9_decodePiece as decodePiece, index$9_encodePoints as encodePoints, index$9_initEc as initEc, index$9_join as join, index$9_lace as lace, index$9_padAndEncodeData as padAndEncodeData, index$9_shardsToChunks as shardsToChunks, index$9_split as split, index$9_transpose as transpose, index$9_unzip as unzip };
-  export type { index$9_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$9_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$9_PIECE_SIZE as PIECE_SIZE, index$9_POINT_LENGTH as POINT_LENGTH };
+  export { index$a as v1 };
+  export type { index$9_IpcHandler as IpcHandler, index$9_IpcSender as IpcSender };
 }
 
 /** Size of the transfer memo. */
@@ -14780,11 +15356,12 @@ declare class MemoryBuilder {
     `;
     this.ensureNotFinalized();
 
-    const range = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
-    const pages = PageRange.fromMemoryRange(range);
+    const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
+    const heapPagesRange = PageRange.fromMemoryRange(heapRange);
+    const initializedPageNumbers = Array.from(this.initialMemory.keys());
 
-    for (const pageNumber of pages) {
-      if (this.initialMemory.has(pageNumber)) {
+    for (const pageNumber of initializedPageNumbers) {
+      if (heapPagesRange.isInRange(pageNumber)) {
         throw new IncorrectSbrkIndex();
       }
     }
@@ -18256,7 +18833,7 @@ 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$j as block, index$q as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$n as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$p 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 { 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_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$8 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_IHostCallMemory as IHostCallMemory, index$3_IHostCallRegisters as IHostCallRegisters, 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 };
 }
 
@@ -19249,4 +19826,4 @@ declare namespace index {
   export type { index_PreimagesInput as PreimagesInput, index_PreimagesState as PreimagesState, index_PreimagesStateUpdate as PreimagesStateUpdate };
 }
 
-export { index$j as block, index$h as block_json, index$q as bytes, index$o as codec, index$m as collections, index$k as config, index$f as config_node, index$l as crypto, index$a as database, index$9 as erasure_coding, index$n as hash, index$6 as jam_host_calls, index$i as json_parser, index$g as logger, index$d as mmr, index$p as numbers, index$r as ordering, index$3 as pvm, index$7 as pvm_host_calls, index$8 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$c as state, index$1 as state_json, index$b as state_merkleization, index as transition, index$e as trie, index$s as utils };
+export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$o as collections, index$m as config, index$h as config_node, index$n as crypto, index$c as database, index$b as erasure_coding, index$9 as fuzz_proto, index$p as hash, index$6 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$7 as pvm_host_calls, index$8 as pvm_interpreter, index$4 as pvm_program, index$5 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 };