@typeberry/lib 0.4.1-818bae8 → 0.4.1-8a21145

package/index.d.ts

@@ -75,32 +75,32 @@ declare const minU64: (a: U64, ...values: U64[]) => U64;
 /** Get the biggest value between U64 a and values given as input parameters. */
 declare const maxU64: (a: U64, ...values: U64[]) => U64;
 
-type index$x_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
-type index$x_U16 = U16;
-type index$x_U32 = U32;
-type index$x_U64 = U64;
-type index$x_U8 = U8;
-type index$x_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
-declare const index$x___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
-declare const index$x_isU16: typeof isU16;
-declare const index$x_isU32: typeof isU32;
-declare const index$x_isU64: typeof isU64;
-declare const index$x_isU8: typeof isU8;
-declare const index$x_leBytesAsU32: typeof leBytesAsU32;
-declare const index$x_maxU64: typeof maxU64;
-declare const index$x_minU64: typeof minU64;
-declare const index$x_sumU32: typeof sumU32;
-declare const index$x_sumU64: typeof sumU64;
-declare const index$x_tryAsU16: typeof tryAsU16;
-declare const index$x_tryAsU32: typeof tryAsU32;
-declare const index$x_tryAsU64: typeof tryAsU64;
-declare const index$x_tryAsU8: typeof tryAsU8;
-declare const index$x_u32AsLeBytes: typeof u32AsLeBytes;
-declare const index$x_u64FromParts: typeof u64FromParts;
-declare const index$x_u64IntoParts: typeof u64IntoParts;
-declare namespace index$x {
-  export { index$x___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$x_isU16 as isU16, index$x_isU32 as isU32, index$x_isU64 as isU64, index$x_isU8 as isU8, index$x_leBytesAsU32 as leBytesAsU32, index$x_maxU64 as maxU64, index$x_minU64 as minU64, index$x_sumU32 as sumU32, index$x_sumU64 as sumU64, index$x_tryAsU16 as tryAsU16, index$x_tryAsU32 as tryAsU32, index$x_tryAsU64 as tryAsU64, index$x_tryAsU8 as tryAsU8, index$x_u32AsLeBytes as u32AsLeBytes, index$x_u64FromParts as u64FromParts, index$x_u64IntoParts as u64IntoParts };
-  export type { index$x_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$x_U16 as U16, index$x_U32 as U32, index$x_U64 as U64, index$x_U8 as U8, index$x_WithBytesRepresentation as WithBytesRepresentation };
+type index$y_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
+type index$y_U16 = U16;
+type index$y_U32 = U32;
+type index$y_U64 = U64;
+type index$y_U8 = U8;
+type index$y_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
+declare const index$y___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
+declare const index$y_isU16: typeof isU16;
+declare const index$y_isU32: typeof isU32;
+declare const index$y_isU64: typeof isU64;
+declare const index$y_isU8: typeof isU8;
+declare const index$y_leBytesAsU32: typeof leBytesAsU32;
+declare const index$y_maxU64: typeof maxU64;
+declare const index$y_minU64: typeof minU64;
+declare const index$y_sumU32: typeof sumU32;
+declare const index$y_sumU64: typeof sumU64;
+declare const index$y_tryAsU16: typeof tryAsU16;
+declare const index$y_tryAsU32: typeof tryAsU32;
+declare const index$y_tryAsU64: typeof tryAsU64;
+declare const index$y_tryAsU8: typeof tryAsU8;
+declare const index$y_u32AsLeBytes: typeof u32AsLeBytes;
+declare const index$y_u64FromParts: typeof u64FromParts;
+declare const index$y_u64IntoParts: typeof u64IntoParts;
+declare namespace index$y {
+  export { index$y___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$y_isU16 as isU16, index$y_isU32 as isU32, index$y_isU64 as isU64, index$y_isU8 as isU8, index$y_leBytesAsU32 as leBytesAsU32, index$y_maxU64 as maxU64, index$y_minU64 as minU64, index$y_sumU32 as sumU32, index$y_sumU64 as sumU64, index$y_tryAsU16 as tryAsU16, index$y_tryAsU32 as tryAsU32, index$y_tryAsU64 as tryAsU64, index$y_tryAsU8 as tryAsU8, index$y_u32AsLeBytes as u32AsLeBytes, index$y_u64FromParts as u64FromParts, index$y_u64IntoParts as u64IntoParts };
+  export type { index$y_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$y_U16 as U16, index$y_U32 as U32, index$y_U64 as U64, index$y_U8 as U8, index$y_WithBytesRepresentation as WithBytesRepresentation };
 }
 
 /** A return value of some comparator. */
@@ -133,12 +133,12 @@ declare class Ordering {
  */
 type Comparator<V> = (self: V, other: V) => Ordering;
 
-type index$w_Comparator<V> = Comparator<V>;
-type index$w_Ordering = Ordering;
-declare const index$w_Ordering: typeof Ordering;
-declare namespace index$w {
-  export { index$w_Ordering as Ordering };
-  export type { index$w_Comparator as Comparator };
+type index$x_Comparator<V> = Comparator<V>;
+type index$x_Ordering = Ordering;
+declare const index$x_Ordering: typeof Ordering;
+declare namespace index$x {
+  export { index$x_Ordering as Ordering };
+  export type { index$x_Comparator as Comparator };
 }
 
 declare enum GpVersion {
@@ -180,6 +180,15 @@ declare class Compatibility {
 }
 
 declare function isBrowser(): boolean;
+/**
+ * Get current time in milliseconds (works in both Node and browser).
+ *
+ * Node.js implementation converts hrtime bigint nanoseconds to milliseconds.
+ * This is safe because dividing nanoseconds by 1_000_000 yields milliseconds,
+ * which remain well below Number.MAX_SAFE_INTEGER for practical runtimes
+ * (would take ~285 years to overflow).
+ */
+declare const now: () => number;
 /**
  * A function to perform runtime assertions.
  *
@@ -212,7 +221,7 @@ declare function assertEmpty<T extends Record<string, never>>(value: T): void;
 /** Debug print an object. */
 declare function inspect<T>(val: T): string;
 /** Utility function to measure time taken for some operation [ms]. */
-declare const measure: (id: string) => () => string;
+declare function measure(id: string): () => string;
 /** A class that adds `toString` method that prints all properties of an object. */
 declare abstract class WithDebug {
     toString(): string;
@@ -240,6 +249,8 @@ declare function lazyInspect<T>(obj: T): {
  */
 declare const workspacePathFix: (workspacePath: string) => (p: string) => string;
 
+declare const env: NodeJS.ProcessEnv;
+
 /**
  * `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
  * specified unique token Token. It means that base type cannot be assigned to unique type by accident.
@@ -369,48 +380,50 @@ declare class ErrorsCollector {
  * as an afterthought.
  */
 
-declare const index$v_CURRENT_SUITE: typeof CURRENT_SUITE;
-declare const index$v_CURRENT_VERSION: typeof CURRENT_VERSION;
-type index$v_Compatibility = Compatibility;
-declare const index$v_Compatibility: typeof Compatibility;
-declare const index$v_DEFAULT_SUITE: typeof DEFAULT_SUITE;
-declare const index$v_DEFAULT_VERSION: typeof DEFAULT_VERSION;
-type index$v_DeepEqualOptions = DeepEqualOptions;
-type index$v_ErrorResult<Error> = ErrorResult<Error>;
-type index$v_ErrorsCollector = ErrorsCollector;
-declare const index$v_ErrorsCollector: typeof ErrorsCollector;
-type index$v_GpVersion = GpVersion;
-declare const index$v_GpVersion: typeof GpVersion;
-declare const index$v_MAX_LENGTH: typeof MAX_LENGTH;
-type index$v_OK = OK;
-type index$v_OkResult<Ok> = OkResult<Ok>;
-type index$v_Opaque<Type, Token extends string> = Opaque<Type, Token>;
-declare const index$v_Result: typeof Result;
-declare const index$v_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
-type index$v_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
-type index$v_TestSuite = TestSuite;
-declare const index$v_TestSuite: typeof TestSuite;
-type index$v_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
-type index$v_WithDebug = WithDebug;
-declare const index$v_WithDebug: typeof WithDebug;
-type index$v_WithOpaque<Token extends string> = WithOpaque<Token>;
-declare const index$v___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
-declare const index$v_asOpaqueType: typeof asOpaqueType;
-declare const index$v_assertEmpty: typeof assertEmpty;
-declare const index$v_assertNever: typeof assertNever;
-declare const index$v_check: typeof check;
-declare const index$v_deepEqual: typeof deepEqual;
-declare const index$v_inspect: typeof inspect;
-declare const index$v_isBrowser: typeof isBrowser;
-declare const index$v_lazyInspect: typeof lazyInspect;
-declare const index$v_measure: typeof measure;
-declare const index$v_resultToString: typeof resultToString;
-declare const index$v_safeAllocUint8Array: typeof safeAllocUint8Array;
-declare const index$v_seeThrough: typeof seeThrough;
-declare const index$v_workspacePathFix: typeof workspacePathFix;
-declare namespace index$v {
-  export { index$v_CURRENT_SUITE as CURRENT_SUITE, index$v_CURRENT_VERSION as CURRENT_VERSION, index$v_Compatibility as Compatibility, index$v_DEFAULT_SUITE as DEFAULT_SUITE, index$v_DEFAULT_VERSION as DEFAULT_VERSION, index$v_ErrorsCollector as ErrorsCollector, index$v_GpVersion as GpVersion, index$v_MAX_LENGTH as MAX_LENGTH, index$v_Result as Result, index$v_TEST_COMPARE_USING as TEST_COMPARE_USING, index$v_TestSuite as TestSuite, index$v_WithDebug as WithDebug, index$v___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$v_asOpaqueType as asOpaqueType, index$v_assertEmpty as assertEmpty, index$v_assertNever as assertNever, index$v_check as check, index$v_deepEqual as deepEqual, index$v_inspect as inspect, index$v_isBrowser as isBrowser, index$v_lazyInspect as lazyInspect, index$v_measure as measure, index$v_resultToString as resultToString, index$v_safeAllocUint8Array as safeAllocUint8Array, index$v_seeThrough as seeThrough, index$v_workspacePathFix as workspacePathFix };
-  export type { index$v_DeepEqualOptions as DeepEqualOptions, index$v_ErrorResult as ErrorResult, index$v_OK as OK, index$v_OkResult as OkResult, index$v_Opaque as Opaque, index$v_TaggedError as TaggedError, index$v_TokenOf as TokenOf, index$v_WithOpaque as WithOpaque };
+declare const index$w_CURRENT_SUITE: typeof CURRENT_SUITE;
+declare const index$w_CURRENT_VERSION: typeof CURRENT_VERSION;
+type index$w_Compatibility = Compatibility;
+declare const index$w_Compatibility: typeof Compatibility;
+declare const index$w_DEFAULT_SUITE: typeof DEFAULT_SUITE;
+declare const index$w_DEFAULT_VERSION: typeof DEFAULT_VERSION;
+type index$w_DeepEqualOptions = DeepEqualOptions;
+type index$w_ErrorResult<Error> = ErrorResult<Error>;
+type index$w_ErrorsCollector = ErrorsCollector;
+declare const index$w_ErrorsCollector: typeof ErrorsCollector;
+type index$w_GpVersion = GpVersion;
+declare const index$w_GpVersion: typeof GpVersion;
+declare const index$w_MAX_LENGTH: typeof MAX_LENGTH;
+type index$w_OK = OK;
+type index$w_OkResult<Ok> = OkResult<Ok>;
+type index$w_Opaque<Type, Token extends string> = Opaque<Type, Token>;
+declare const index$w_Result: typeof Result;
+declare const index$w_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
+type index$w_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
+type index$w_TestSuite = TestSuite;
+declare const index$w_TestSuite: typeof TestSuite;
+type index$w_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
+type index$w_WithDebug = WithDebug;
+declare const index$w_WithDebug: typeof WithDebug;
+type index$w_WithOpaque<Token extends string> = WithOpaque<Token>;
+declare const index$w___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
+declare const index$w_asOpaqueType: typeof asOpaqueType;
+declare const index$w_assertEmpty: typeof assertEmpty;
+declare const index$w_assertNever: typeof assertNever;
+declare const index$w_check: typeof check;
+declare const index$w_deepEqual: typeof deepEqual;
+declare const index$w_env: typeof env;
+declare const index$w_inspect: typeof inspect;
+declare const index$w_isBrowser: typeof isBrowser;
+declare const index$w_lazyInspect: typeof lazyInspect;
+declare const index$w_measure: typeof measure;
+declare const index$w_now: typeof now;
+declare const index$w_resultToString: typeof resultToString;
+declare const index$w_safeAllocUint8Array: typeof safeAllocUint8Array;
+declare const index$w_seeThrough: typeof seeThrough;
+declare const index$w_workspacePathFix: typeof workspacePathFix;
+declare namespace index$w {
+  export { index$w_CURRENT_SUITE as CURRENT_SUITE, index$w_CURRENT_VERSION as CURRENT_VERSION, index$w_Compatibility as Compatibility, index$w_DEFAULT_SUITE as DEFAULT_SUITE, index$w_DEFAULT_VERSION as DEFAULT_VERSION, index$w_ErrorsCollector as ErrorsCollector, index$w_GpVersion as GpVersion, index$w_MAX_LENGTH as MAX_LENGTH, index$w_Result as Result, index$w_TEST_COMPARE_USING as TEST_COMPARE_USING, index$w_TestSuite as TestSuite, index$w_WithDebug as WithDebug, index$w___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$w_asOpaqueType as asOpaqueType, index$w_assertEmpty as assertEmpty, index$w_assertNever as assertNever, index$w_check as check, index$w_deepEqual as deepEqual, index$w_env as env, index$w_inspect as inspect, index$w_isBrowser as isBrowser, index$w_lazyInspect as lazyInspect, index$w_measure as measure, index$w_now as now, index$w_resultToString as resultToString, index$w_safeAllocUint8Array as safeAllocUint8Array, index$w_seeThrough as seeThrough, index$w_workspacePathFix as workspacePathFix };
+  export type { index$w_DeepEqualOptions as DeepEqualOptions, index$w_ErrorResult as ErrorResult, index$w_OK as OK, index$w_OkResult as OkResult, index$w_Opaque as Opaque, index$w_TaggedError as TaggedError, index$w_TokenOf as TokenOf, index$w_WithOpaque as WithOpaque };
 }
 
 /**
@@ -522,19 +535,19 @@ declare class BitVec {
     indicesOfSetBits(): Generator<number, void, unknown>;
 }
 
-type index$u_BitVec = BitVec;
-declare const index$u_BitVec: typeof BitVec;
-type index$u_Bytes<T extends number> = Bytes<T>;
-declare const index$u_Bytes: typeof Bytes;
-type index$u_BytesBlob = BytesBlob;
-declare const index$u_BytesBlob: typeof BytesBlob;
-declare const index$u_bytesBlobComparator: typeof bytesBlobComparator;
-declare namespace index$u {
+type index$v_BitVec = BitVec;
+declare const index$v_BitVec: typeof BitVec;
+type index$v_Bytes<T extends number> = Bytes<T>;
+declare const index$v_Bytes: typeof Bytes;
+type index$v_BytesBlob = BytesBlob;
+declare const index$v_BytesBlob: typeof BytesBlob;
+declare const index$v_bytesBlobComparator: typeof bytesBlobComparator;
+declare namespace index$v {
   export {
-    index$u_BitVec as BitVec,
-    index$u_Bytes as Bytes,
-    index$u_BytesBlob as BytesBlob,
-    index$u_bytesBlobComparator as bytesBlobComparator,
+    index$v_BitVec as BitVec,
+    index$v_Bytes as Bytes,
+    index$v_BytesBlob as BytesBlob,
+    index$v_bytesBlobComparator as bytesBlobComparator,
   };
 }
 
@@ -1263,41 +1276,41 @@ declare namespace descriptors {
   export type { descriptors_SequenceVarLenOptions as SequenceVarLenOptions };
 }
 
-type index$t_ClassConstructor<T> = ClassConstructor<T>;
-type index$t_Codec<T> = Codec<T>;
-type index$t_CodecRecord<T> = CodecRecord<T>;
-type index$t_CodecWithView<T, V> = CodecWithView<T, V>;
-type index$t_Decode<T> = Decode<T>;
-type index$t_Decoder = Decoder;
-declare const index$t_Decoder: typeof Decoder;
-type index$t_DescribedBy<T> = DescribedBy<T>;
-type index$t_Descriptor<T, V = T> = Descriptor<T, V>;
-declare const index$t_Descriptor: typeof Descriptor;
-type index$t_DescriptorRecord<T> = DescriptorRecord<T>;
-type index$t_Encode<T> = Encode<T>;
-type index$t_Encoder = Encoder;
-declare const index$t_Encoder: typeof Encoder;
-type index$t_EndOfDataError = EndOfDataError;
-declare const index$t_EndOfDataError: typeof EndOfDataError;
-type index$t_LengthRange = LengthRange;
-type index$t_ObjectView<T> = ObjectView<T>;
-declare const index$t_ObjectView: typeof ObjectView;
-type index$t_OptionalRecord<T> = OptionalRecord<T>;
-type index$t_PropertyKeys<T> = PropertyKeys<T>;
-type index$t_SequenceView<T, V = T> = SequenceView<T, V>;
-declare const index$t_SequenceView: typeof SequenceView;
-type index$t_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
-type index$t_SizeHint = SizeHint;
-type index$t_ViewField<T, V> = ViewField<T, V>;
-declare const index$t_ViewField: typeof ViewField;
-type index$t_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
-declare const index$t_addSizeHints: typeof addSizeHints;
-declare const index$t_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
-declare const index$t_tryAsExactBytes: typeof tryAsExactBytes;
-declare const index$t_validateLength: typeof validateLength;
-declare namespace index$t {
-  export { index$t_Decoder as Decoder, index$t_Descriptor as Descriptor, index$t_Encoder as Encoder, index$t_EndOfDataError as EndOfDataError, index$t_ObjectView as ObjectView, index$t_SequenceView as SequenceView, index$t_ViewField as ViewField, index$t_addSizeHints as addSizeHints, descriptors as codec, index$t_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$t_tryAsExactBytes as tryAsExactBytes, index$t_validateLength as validateLength };
-  export type { index$t_ClassConstructor as ClassConstructor, index$t_Codec as Codec, index$t_CodecRecord as CodecRecord, index$t_CodecWithView as CodecWithView, index$t_Decode as Decode, index$t_DescribedBy as DescribedBy, index$t_DescriptorRecord as DescriptorRecord, index$t_Encode as Encode, index$t_LengthRange as LengthRange, index$t_OptionalRecord as OptionalRecord, Options$1 as Options, index$t_PropertyKeys as PropertyKeys, index$t_SimpleDescriptorRecord as SimpleDescriptorRecord, index$t_SizeHint as SizeHint, index$t_ViewOf as ViewOf };
+type index$u_ClassConstructor<T> = ClassConstructor<T>;
+type index$u_Codec<T> = Codec<T>;
+type index$u_CodecRecord<T> = CodecRecord<T>;
+type index$u_CodecWithView<T, V> = CodecWithView<T, V>;
+type index$u_Decode<T> = Decode<T>;
+type index$u_Decoder = Decoder;
+declare const index$u_Decoder: typeof Decoder;
+type index$u_DescribedBy<T> = DescribedBy<T>;
+type index$u_Descriptor<T, V = T> = Descriptor<T, V>;
+declare const index$u_Descriptor: typeof Descriptor;
+type index$u_DescriptorRecord<T> = DescriptorRecord<T>;
+type index$u_Encode<T> = Encode<T>;
+type index$u_Encoder = Encoder;
+declare const index$u_Encoder: typeof Encoder;
+type index$u_EndOfDataError = EndOfDataError;
+declare const index$u_EndOfDataError: typeof EndOfDataError;
+type index$u_LengthRange = LengthRange;
+type index$u_ObjectView<T> = ObjectView<T>;
+declare const index$u_ObjectView: typeof ObjectView;
+type index$u_OptionalRecord<T> = OptionalRecord<T>;
+type index$u_PropertyKeys<T> = PropertyKeys<T>;
+type index$u_SequenceView<T, V = T> = SequenceView<T, V>;
+declare const index$u_SequenceView: typeof SequenceView;
+type index$u_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
+type index$u_SizeHint = SizeHint;
+type index$u_ViewField<T, V> = ViewField<T, V>;
+declare const index$u_ViewField: typeof ViewField;
+type index$u_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
+declare const index$u_addSizeHints: typeof addSizeHints;
+declare const index$u_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
+declare const index$u_tryAsExactBytes: typeof tryAsExactBytes;
+declare const index$u_validateLength: typeof validateLength;
+declare namespace index$u {
+  export { index$u_Decoder as Decoder, index$u_Descriptor as Descriptor, index$u_Encoder as Encoder, index$u_EndOfDataError as EndOfDataError, index$u_ObjectView as ObjectView, index$u_SequenceView as SequenceView, index$u_ViewField as ViewField, index$u_addSizeHints as addSizeHints, descriptors as codec, index$u_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$u_tryAsExactBytes as tryAsExactBytes, index$u_validateLength as validateLength };
+  export type { index$u_ClassConstructor as ClassConstructor, index$u_Codec as Codec, index$u_CodecRecord as CodecRecord, index$u_CodecWithView as CodecWithView, index$u_Decode as Decode, index$u_DescribedBy as DescribedBy, index$u_DescriptorRecord as DescriptorRecord, index$u_Encode as Encode, index$u_LengthRange as LengthRange, index$u_OptionalRecord as OptionalRecord, Options$1 as Options, index$u_PropertyKeys as PropertyKeys, index$u_SimpleDescriptorRecord as SimpleDescriptorRecord, index$u_SizeHint as SizeHint, index$u_ViewOf as ViewOf };
 }
 
 /**
@@ -1644,23 +1657,23 @@ declare namespace keccak {
   };
 }
 
-type index$s_Blake2b = Blake2b;
-declare const index$s_Blake2b: typeof Blake2b;
-type index$s_Blake2bHash = Blake2bHash;
-type index$s_HASH_SIZE = HASH_SIZE;
-type index$s_KeccakHash = KeccakHash;
-type index$s_OpaqueHash = OpaqueHash;
-type index$s_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
-type index$s_TruncatedHash = TruncatedHash;
-type index$s_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
-declare const index$s_WithHash: typeof WithHash;
-type index$s_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
-declare const index$s_WithHashAndBytes: typeof WithHashAndBytes;
-declare const index$s_ZERO_HASH: typeof ZERO_HASH;
-declare const index$s_keccak: typeof keccak;
-declare namespace index$s {
-  export { index$s_Blake2b as Blake2b, index$s_WithHash as WithHash, index$s_WithHashAndBytes as WithHashAndBytes, index$s_ZERO_HASH as ZERO_HASH, index$s_keccak as keccak };
-  export type { index$s_Blake2bHash as Blake2bHash, index$s_HASH_SIZE as HASH_SIZE, index$s_KeccakHash as KeccakHash, index$s_OpaqueHash as OpaqueHash, index$s_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$s_TruncatedHash as TruncatedHash };
+type index$t_Blake2b = Blake2b;
+declare const index$t_Blake2b: typeof Blake2b;
+type index$t_Blake2bHash = Blake2bHash;
+type index$t_HASH_SIZE = HASH_SIZE;
+type index$t_KeccakHash = KeccakHash;
+type index$t_OpaqueHash = OpaqueHash;
+type index$t_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
+type index$t_TruncatedHash = TruncatedHash;
+type index$t_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
+declare const index$t_WithHash: typeof WithHash;
+type index$t_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
+declare const index$t_WithHashAndBytes: typeof WithHashAndBytes;
+declare const index$t_ZERO_HASH: typeof ZERO_HASH;
+declare const index$t_keccak: typeof keccak;
+declare namespace index$t {
+  export { index$t_Blake2b as Blake2b, index$t_WithHash as WithHash, index$t_WithHashAndBytes as WithHashAndBytes, index$t_ZERO_HASH as ZERO_HASH, index$t_keccak as keccak };
+  export type { index$t_Blake2bHash as Blake2bHash, index$t_HASH_SIZE as HASH_SIZE, index$t_KeccakHash as KeccakHash, index$t_OpaqueHash as OpaqueHash, index$t_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$t_TruncatedHash as TruncatedHash };
 }
 
 /** Immutable view of the `HashDictionary`. */
@@ -1961,41 +1974,41 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
     [Symbol.iterator](): Generator<[TruncatedHash, V], any, any>;
 }
 
-type index$r_ArrayView<T> = ArrayView<T>;
-declare const index$r_ArrayView: typeof ArrayView;
-type index$r_BlobDictionary<K extends BytesBlob, V> = BlobDictionary<K, V>;
-declare const index$r_BlobDictionary: typeof BlobDictionary;
-type index$r_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
-declare const index$r_FixedSizeArray: typeof FixedSizeArray;
-type index$r_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
-declare const index$r_HashDictionary: typeof HashDictionary;
-type index$r_HashSet<V extends OpaqueHash> = HashSet<V>;
-declare const index$r_HashSet: typeof HashSet;
-type index$r_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
-type index$r_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
-type index$r_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
-type index$r_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
-type index$r_KeyMapper<K> = KeyMapper<K>;
-type index$r_KnownSize<T, F extends string> = KnownSize<T, F>;
-type index$r_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
-type index$r_KnownSizeId<X> = KnownSizeId<X>;
-type index$r_ListChildren<K extends BytesBlob, V> = ListChildren<K, V>;
-declare const index$r_ListChildren: typeof ListChildren;
-type index$r_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
-declare const index$r_MultiMap: typeof MultiMap;
-type index$r_SortedArray<V> = SortedArray<V>;
-declare const index$r_SortedArray: typeof SortedArray;
-type index$r_SortedSet<V> = SortedSet<V>;
-declare const index$r_SortedSet: typeof SortedSet;
-type index$r_StringHashDictionary<K extends OpaqueHash, V> = StringHashDictionary<K, V>;
-declare const index$r_StringHashDictionary: typeof StringHashDictionary;
-type index$r_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
-declare const index$r_TruncatedHashDictionary: typeof TruncatedHashDictionary;
-declare const index$r_asKnownSize: typeof asKnownSize;
-declare const index$r_bytesAsU48: typeof bytesAsU48;
-declare namespace index$r {
-  export { index$r_ArrayView as ArrayView, index$r_BlobDictionary as BlobDictionary, index$r_FixedSizeArray as FixedSizeArray, index$r_HashDictionary as HashDictionary, index$r_HashSet as HashSet, index$r_ListChildren as ListChildren, index$r_MultiMap as MultiMap, index$r_SortedArray as SortedArray, index$r_SortedSet as SortedSet, index$r_StringHashDictionary as StringHashDictionary, index$r_TruncatedHashDictionary as TruncatedHashDictionary, index$r_asKnownSize as asKnownSize, index$r_bytesAsU48 as bytesAsU48 };
-  export type { index$r_ImmutableHashDictionary as ImmutableHashDictionary, index$r_ImmutableHashSet as ImmutableHashSet, index$r_ImmutableSortedArray as ImmutableSortedArray, index$r_ImmutableSortedSet as ImmutableSortedSet, index$r_KeyMapper as KeyMapper, index$r_KnownSize as KnownSize, index$r_KnownSizeArray as KnownSizeArray, index$r_KnownSizeId as KnownSizeId };
+type index$s_ArrayView<T> = ArrayView<T>;
+declare const index$s_ArrayView: typeof ArrayView;
+type index$s_BlobDictionary<K extends BytesBlob, V> = BlobDictionary<K, V>;
+declare const index$s_BlobDictionary: typeof BlobDictionary;
+type index$s_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
+declare const index$s_FixedSizeArray: typeof FixedSizeArray;
+type index$s_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
+declare const index$s_HashDictionary: typeof HashDictionary;
+type index$s_HashSet<V extends OpaqueHash> = HashSet<V>;
+declare const index$s_HashSet: typeof HashSet;
+type index$s_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
+type index$s_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
+type index$s_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
+type index$s_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
+type index$s_KeyMapper<K> = KeyMapper<K>;
+type index$s_KnownSize<T, F extends string> = KnownSize<T, F>;
+type index$s_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
+type index$s_KnownSizeId<X> = KnownSizeId<X>;
+type index$s_ListChildren<K extends BytesBlob, V> = ListChildren<K, V>;
+declare const index$s_ListChildren: typeof ListChildren;
+type index$s_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
+declare const index$s_MultiMap: typeof MultiMap;
+type index$s_SortedArray<V> = SortedArray<V>;
+declare const index$s_SortedArray: typeof SortedArray;
+type index$s_SortedSet<V> = SortedSet<V>;
+declare const index$s_SortedSet: typeof SortedSet;
+type index$s_StringHashDictionary<K extends OpaqueHash, V> = StringHashDictionary<K, V>;
+declare const index$s_StringHashDictionary: typeof StringHashDictionary;
+type index$s_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
+declare const index$s_TruncatedHashDictionary: typeof TruncatedHashDictionary;
+declare const index$s_asKnownSize: typeof asKnownSize;
+declare const index$s_bytesAsU48: typeof bytesAsU48;
+declare namespace index$s {
+  export { index$s_ArrayView as ArrayView, index$s_BlobDictionary as BlobDictionary, index$s_FixedSizeArray as FixedSizeArray, index$s_HashDictionary as HashDictionary, index$s_HashSet as HashSet, index$s_ListChildren as ListChildren, index$s_MultiMap as MultiMap, index$s_SortedArray as SortedArray, index$s_SortedSet as SortedSet, index$s_StringHashDictionary as StringHashDictionary, index$s_TruncatedHashDictionary as TruncatedHashDictionary, index$s_asKnownSize as asKnownSize, index$s_bytesAsU48 as bytesAsU48 };
+  export type { index$s_ImmutableHashDictionary as ImmutableHashDictionary, index$s_ImmutableHashSet as ImmutableHashSet, index$s_ImmutableSortedArray as ImmutableSortedArray, index$s_ImmutableSortedSet as ImmutableSortedSet, index$s_KeyMapper as KeyMapper, index$s_KnownSize as KnownSize, index$s_KnownSizeArray as KnownSizeArray, index$s_KnownSizeId as KnownSizeId };
 }
 
 declare namespace bandersnatch_d_exports {
@@ -2259,32 +2272,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$q_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
-type index$q_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
-type index$q_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
-type index$q_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
-type index$q_BLS_KEY_BYTES = BLS_KEY_BYTES;
-type index$q_BandersnatchKey = BandersnatchKey;
-type index$q_BandersnatchProof = BandersnatchProof;
-type index$q_BandersnatchRingRoot = BandersnatchRingRoot;
-type index$q_BandersnatchSecretSeed = BandersnatchSecretSeed;
-type index$q_BandersnatchVrfSignature = BandersnatchVrfSignature;
-type index$q_BlsKey = BlsKey;
-type index$q_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
-type index$q_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
-type index$q_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
-type index$q_Ed25519Key = Ed25519Key;
-type index$q_Ed25519Pair = Ed25519Pair;
-declare const index$q_Ed25519Pair: typeof Ed25519Pair;
-type index$q_Ed25519SecretSeed = Ed25519SecretSeed;
-type index$q_Ed25519Signature = Ed25519Signature;
-type index$q_SEED_SIZE = SEED_SIZE;
-declare const index$q_bandersnatch: typeof bandersnatch;
-declare const index$q_ed25519: typeof ed25519;
-declare const index$q_keyDerivation: typeof keyDerivation;
-declare namespace index$q {
-  export { index$q_Ed25519Pair as Ed25519Pair, index$q_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$q_ed25519 as ed25519, initAll as initWasm, index$q_keyDerivation as keyDerivation };
-  export type { index$q_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$q_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$q_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$q_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$q_BLS_KEY_BYTES as BLS_KEY_BYTES, index$q_BandersnatchKey as BandersnatchKey, index$q_BandersnatchProof as BandersnatchProof, index$q_BandersnatchRingRoot as BandersnatchRingRoot, index$q_BandersnatchSecretSeed as BandersnatchSecretSeed, index$q_BandersnatchVrfSignature as BandersnatchVrfSignature, index$q_BlsKey as BlsKey, index$q_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$q_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$q_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$q_Ed25519Key as Ed25519Key, index$q_Ed25519SecretSeed as Ed25519SecretSeed, index$q_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$q_SEED_SIZE as SEED_SIZE };
+type index$r_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
+type index$r_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
+type index$r_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
+type index$r_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
+type index$r_BLS_KEY_BYTES = BLS_KEY_BYTES;
+type index$r_BandersnatchKey = BandersnatchKey;
+type index$r_BandersnatchProof = BandersnatchProof;
+type index$r_BandersnatchRingRoot = BandersnatchRingRoot;
+type index$r_BandersnatchSecretSeed = BandersnatchSecretSeed;
+type index$r_BandersnatchVrfSignature = BandersnatchVrfSignature;
+type index$r_BlsKey = BlsKey;
+type index$r_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
+type index$r_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
+type index$r_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
+type index$r_Ed25519Key = Ed25519Key;
+type index$r_Ed25519Pair = Ed25519Pair;
+declare const index$r_Ed25519Pair: typeof Ed25519Pair;
+type index$r_Ed25519SecretSeed = Ed25519SecretSeed;
+type index$r_Ed25519Signature = Ed25519Signature;
+type index$r_SEED_SIZE = SEED_SIZE;
+declare const index$r_bandersnatch: typeof bandersnatch;
+declare const index$r_ed25519: typeof ed25519;
+declare const index$r_keyDerivation: typeof keyDerivation;
+declare namespace index$r {
+  export { index$r_Ed25519Pair as Ed25519Pair, index$r_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$r_ed25519 as ed25519, initAll as initWasm, index$r_keyDerivation as keyDerivation };
+  export type { index$r_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$r_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$r_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$r_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$r_BLS_KEY_BYTES as BLS_KEY_BYTES, index$r_BandersnatchKey as BandersnatchKey, index$r_BandersnatchProof as BandersnatchProof, index$r_BandersnatchRingRoot as BandersnatchRingRoot, index$r_BandersnatchSecretSeed as BandersnatchSecretSeed, index$r_BandersnatchVrfSignature as BandersnatchVrfSignature, index$r_BlsKey as BlsKey, index$r_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$r_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$r_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$r_Ed25519Key as Ed25519Key, index$r_Ed25519SecretSeed as Ed25519SecretSeed, index$r_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$r_SEED_SIZE as SEED_SIZE };
 }
 
 /**
@@ -2413,25 +2426,25 @@ declare enum PvmBackend {
     Ananas = 1
 }
 
-type index$p_Bootnode = Bootnode;
-declare const index$p_Bootnode: typeof Bootnode;
-type index$p_ChainSpec = ChainSpec;
-declare const index$p_ChainSpec: typeof ChainSpec;
-declare const index$p_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
-declare const index$p_EST_CORES: typeof EST_CORES;
-declare const index$p_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
-declare const index$p_EST_VALIDATORS: typeof EST_VALIDATORS;
-declare const index$p_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
-type index$p_PeerAddress = PeerAddress;
-type index$p_PeerId = PeerId;
-type index$p_PvmBackend = PvmBackend;
-declare const index$p_PvmBackend: typeof PvmBackend;
-declare const index$p_PvmBackendNames: typeof PvmBackendNames;
-declare const index$p_fullChainSpec: typeof fullChainSpec;
-declare const index$p_tinyChainSpec: typeof tinyChainSpec;
-declare namespace index$p {
-  export { index$p_Bootnode as Bootnode, index$p_ChainSpec as ChainSpec, index$p_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$p_EST_CORES as EST_CORES, index$p_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$p_EST_VALIDATORS as EST_VALIDATORS, index$p_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$p_PvmBackend as PvmBackend, index$p_PvmBackendNames as PvmBackendNames, index$p_fullChainSpec as fullChainSpec, index$p_tinyChainSpec as tinyChainSpec };
-  export type { index$p_PeerAddress as PeerAddress, index$p_PeerId as PeerId };
+type index$q_Bootnode = Bootnode;
+declare const index$q_Bootnode: typeof Bootnode;
+type index$q_ChainSpec = ChainSpec;
+declare const index$q_ChainSpec: typeof ChainSpec;
+declare const index$q_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
+declare const index$q_EST_CORES: typeof EST_CORES;
+declare const index$q_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
+declare const index$q_EST_VALIDATORS: typeof EST_VALIDATORS;
+declare const index$q_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
+type index$q_PeerAddress = PeerAddress;
+type index$q_PeerId = PeerId;
+type index$q_PvmBackend = PvmBackend;
+declare const index$q_PvmBackend: typeof PvmBackend;
+declare const index$q_PvmBackendNames: typeof PvmBackendNames;
+declare const index$q_fullChainSpec: typeof fullChainSpec;
+declare const index$q_tinyChainSpec: typeof tinyChainSpec;
+declare namespace index$q {
+  export { index$q_Bootnode as Bootnode, index$q_ChainSpec as ChainSpec, index$q_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$q_EST_CORES as EST_CORES, index$q_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$q_EST_VALIDATORS as EST_VALIDATORS, index$q_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$q_PvmBackend as PvmBackend, index$q_PvmBackendNames as PvmBackendNames, index$q_fullChainSpec as fullChainSpec, index$q_tinyChainSpec as tinyChainSpec };
+  export type { index$q_PeerAddress as PeerAddress, index$q_PeerId as PeerId };
 }
 
 /**
@@ -4041,72 +4054,72 @@ declare namespace codecUtils {
  */
 declare function reencodeAsView<T, V>(codec: Descriptor<T, V>, object: T, chainSpec?: ChainSpec): V;
 
-type index$o_Block = Block;
-declare const index$o_Block: typeof Block;
-type index$o_BlockView = BlockView;
-type index$o_CodeHash = CodeHash;
-type index$o_CoreIndex = CoreIndex;
-type index$o_EntropyHash = EntropyHash;
-type index$o_Epoch = Epoch;
-type index$o_EpochMarker = EpochMarker;
-declare const index$o_EpochMarker: typeof EpochMarker;
-type index$o_EpochMarkerView = EpochMarkerView;
-type index$o_Extrinsic = Extrinsic;
-declare const index$o_Extrinsic: typeof Extrinsic;
-type index$o_ExtrinsicHash = ExtrinsicHash;
-type index$o_ExtrinsicView = ExtrinsicView;
-type index$o_Header = Header;
-declare const index$o_Header: typeof Header;
-type index$o_HeaderHash = HeaderHash;
-type index$o_HeaderView = HeaderView;
-declare const index$o_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
-type index$o_PerEpochBlock<T> = PerEpochBlock<T>;
-type index$o_PerValidator<T> = PerValidator<T>;
-type index$o_SEGMENT_BYTES = SEGMENT_BYTES;
-type index$o_Segment = Segment;
-type index$o_SegmentIndex = SegmentIndex;
-type index$o_ServiceGas = ServiceGas;
-type index$o_ServiceId = ServiceId;
-type index$o_StateRootHash = StateRootHash;
-type index$o_TicketsMarker = TicketsMarker;
-declare const index$o_TicketsMarker: typeof TicketsMarker;
-type index$o_TicketsMarkerView = TicketsMarkerView;
-type index$o_TimeSlot = TimeSlot;
-type index$o_ValidatorIndex = ValidatorIndex;
-type index$o_ValidatorKeys = ValidatorKeys;
-declare const index$o_ValidatorKeys: typeof ValidatorKeys;
-declare const index$o_W_E: typeof W_E;
-declare const index$o_W_S: typeof W_S;
-type index$o_WorkReportHash = WorkReportHash;
-declare const index$o_assurances: typeof assurances;
-declare const index$o_codecPerEpochBlock: typeof codecPerEpochBlock;
-declare const index$o_codecPerValidator: typeof codecPerValidator;
-declare const index$o_codecUtils: typeof codecUtils;
-declare const index$o_disputes: typeof disputes;
-declare const index$o_emptyBlock: typeof emptyBlock;
-declare const index$o_encodeUnsealedHeader: typeof encodeUnsealedHeader;
-declare const index$o_guarantees: typeof guarantees;
-declare const index$o_headerViewWithHashCodec: typeof headerViewWithHashCodec;
-declare const index$o_preimage: typeof preimage;
-declare const index$o_reencodeAsView: typeof reencodeAsView;
-declare const index$o_refineContext: typeof refineContext;
-declare const index$o_tickets: typeof tickets;
-declare const index$o_tryAsCoreIndex: typeof tryAsCoreIndex;
-declare const index$o_tryAsEpoch: typeof tryAsEpoch;
-declare const index$o_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
-declare const index$o_tryAsPerValidator: typeof tryAsPerValidator;
-declare const index$o_tryAsSegmentIndex: typeof tryAsSegmentIndex;
-declare const index$o_tryAsServiceGas: typeof tryAsServiceGas;
-declare const index$o_tryAsServiceId: typeof tryAsServiceId;
-declare const index$o_tryAsTimeSlot: typeof tryAsTimeSlot;
-declare const index$o_tryAsValidatorIndex: typeof tryAsValidatorIndex;
-declare const index$o_workItem: typeof workItem;
-declare const index$o_workPackage: typeof workPackage;
-declare const index$o_workReport: typeof workReport;
-declare const index$o_workResult: typeof workResult;
-declare namespace index$o {
-  export { index$o_Block as Block, index$o_EpochMarker as EpochMarker, index$o_Extrinsic as Extrinsic, index$o_Header as Header, index$o_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$o_TicketsMarker as TicketsMarker, index$o_ValidatorKeys as ValidatorKeys, index$o_W_E as W_E, index$o_W_S as W_S, index$o_assurances as assurances, index$o_codecPerEpochBlock as codecPerEpochBlock, index$o_codecPerValidator as codecPerValidator, index$o_codecUtils as codecUtils, index$o_disputes as disputes, index$o_emptyBlock as emptyBlock, index$o_encodeUnsealedHeader as encodeUnsealedHeader, index$o_guarantees as guarantees, index$o_headerViewWithHashCodec as headerViewWithHashCodec, index$o_preimage as preimage, index$o_reencodeAsView as reencodeAsView, index$o_refineContext as refineContext, index$o_tickets as tickets, index$o_tryAsCoreIndex as tryAsCoreIndex, index$o_tryAsEpoch as tryAsEpoch, index$o_tryAsPerEpochBlock as tryAsPerEpochBlock, index$o_tryAsPerValidator as tryAsPerValidator, index$o_tryAsSegmentIndex as tryAsSegmentIndex, index$o_tryAsServiceGas as tryAsServiceGas, index$o_tryAsServiceId as tryAsServiceId, index$o_tryAsTimeSlot as tryAsTimeSlot, index$o_tryAsValidatorIndex as tryAsValidatorIndex, index$o_workItem as workItem, index$o_workPackage as workPackage, index$o_workReport as workReport, index$o_workResult as workResult };
-  export type { index$o_BlockView as BlockView, index$o_CodeHash as CodeHash, index$o_CoreIndex as CoreIndex, index$o_EntropyHash as EntropyHash, index$o_Epoch as Epoch, index$o_EpochMarkerView as EpochMarkerView, index$o_ExtrinsicHash as ExtrinsicHash, index$o_ExtrinsicView as ExtrinsicView, index$o_HeaderHash as HeaderHash, index$o_HeaderView as HeaderView, index$o_PerEpochBlock as PerEpochBlock, index$o_PerValidator as PerValidator, index$o_SEGMENT_BYTES as SEGMENT_BYTES, index$o_Segment as Segment, index$o_SegmentIndex as SegmentIndex, index$o_ServiceGas as ServiceGas, index$o_ServiceId as ServiceId, index$o_StateRootHash as StateRootHash, index$o_TicketsMarkerView as TicketsMarkerView, index$o_TimeSlot as TimeSlot, index$o_ValidatorIndex as ValidatorIndex, index$o_WorkReportHash as WorkReportHash };
+type index$p_Block = Block;
+declare const index$p_Block: typeof Block;
+type index$p_BlockView = BlockView;
+type index$p_CodeHash = CodeHash;
+type index$p_CoreIndex = CoreIndex;
+type index$p_EntropyHash = EntropyHash;
+type index$p_Epoch = Epoch;
+type index$p_EpochMarker = EpochMarker;
+declare const index$p_EpochMarker: typeof EpochMarker;
+type index$p_EpochMarkerView = EpochMarkerView;
+type index$p_Extrinsic = Extrinsic;
+declare const index$p_Extrinsic: typeof Extrinsic;
+type index$p_ExtrinsicHash = ExtrinsicHash;
+type index$p_ExtrinsicView = ExtrinsicView;
+type index$p_Header = Header;
+declare const index$p_Header: typeof Header;
+type index$p_HeaderHash = HeaderHash;
+type index$p_HeaderView = HeaderView;
+declare const index$p_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
+type index$p_PerEpochBlock<T> = PerEpochBlock<T>;
+type index$p_PerValidator<T> = PerValidator<T>;
+type index$p_SEGMENT_BYTES = SEGMENT_BYTES;
+type index$p_Segment = Segment;
+type index$p_SegmentIndex = SegmentIndex;
+type index$p_ServiceGas = ServiceGas;
+type index$p_ServiceId = ServiceId;
+type index$p_StateRootHash = StateRootHash;
+type index$p_TicketsMarker = TicketsMarker;
+declare const index$p_TicketsMarker: typeof TicketsMarker;
+type index$p_TicketsMarkerView = TicketsMarkerView;
+type index$p_TimeSlot = TimeSlot;
+type index$p_ValidatorIndex = ValidatorIndex;
+type index$p_ValidatorKeys = ValidatorKeys;
+declare const index$p_ValidatorKeys: typeof ValidatorKeys;
+declare const index$p_W_E: typeof W_E;
+declare const index$p_W_S: typeof W_S;
+type index$p_WorkReportHash = WorkReportHash;
+declare const index$p_assurances: typeof assurances;
+declare const index$p_codecPerEpochBlock: typeof codecPerEpochBlock;
+declare const index$p_codecPerValidator: typeof codecPerValidator;
+declare const index$p_codecUtils: typeof codecUtils;
+declare const index$p_disputes: typeof disputes;
+declare const index$p_emptyBlock: typeof emptyBlock;
+declare const index$p_encodeUnsealedHeader: typeof encodeUnsealedHeader;
+declare const index$p_guarantees: typeof guarantees;
+declare const index$p_headerViewWithHashCodec: typeof headerViewWithHashCodec;
+declare const index$p_preimage: typeof preimage;
+declare const index$p_reencodeAsView: typeof reencodeAsView;
+declare const index$p_refineContext: typeof refineContext;
+declare const index$p_tickets: typeof tickets;
+declare const index$p_tryAsCoreIndex: typeof tryAsCoreIndex;
+declare const index$p_tryAsEpoch: typeof tryAsEpoch;
+declare const index$p_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
+declare const index$p_tryAsPerValidator: typeof tryAsPerValidator;
+declare const index$p_tryAsSegmentIndex: typeof tryAsSegmentIndex;
+declare const index$p_tryAsServiceGas: typeof tryAsServiceGas;
+declare const index$p_tryAsServiceId: typeof tryAsServiceId;
+declare const index$p_tryAsTimeSlot: typeof tryAsTimeSlot;
+declare const index$p_tryAsValidatorIndex: typeof tryAsValidatorIndex;
+declare const index$p_workItem: typeof workItem;
+declare const index$p_workPackage: typeof workPackage;
+declare const index$p_workReport: typeof workReport;
+declare const index$p_workResult: typeof workResult;
+declare namespace index$p {
+  export { index$p_Block as Block, index$p_EpochMarker as EpochMarker, index$p_Extrinsic as Extrinsic, index$p_Header as Header, index$p_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$p_TicketsMarker as TicketsMarker, index$p_ValidatorKeys as ValidatorKeys, index$p_W_E as W_E, index$p_W_S as W_S, index$p_assurances as assurances, index$p_codecPerEpochBlock as codecPerEpochBlock, index$p_codecPerValidator as codecPerValidator, index$p_codecUtils as codecUtils, index$p_disputes as disputes, index$p_emptyBlock as emptyBlock, index$p_encodeUnsealedHeader as encodeUnsealedHeader, index$p_guarantees as guarantees, index$p_headerViewWithHashCodec as headerViewWithHashCodec, index$p_preimage as preimage, index$p_reencodeAsView as reencodeAsView, index$p_refineContext as refineContext, index$p_tickets as tickets, index$p_tryAsCoreIndex as tryAsCoreIndex, index$p_tryAsEpoch as tryAsEpoch, index$p_tryAsPerEpochBlock as tryAsPerEpochBlock, index$p_tryAsPerValidator as tryAsPerValidator, index$p_tryAsSegmentIndex as tryAsSegmentIndex, index$p_tryAsServiceGas as tryAsServiceGas, index$p_tryAsServiceId as tryAsServiceId, index$p_tryAsTimeSlot as tryAsTimeSlot, index$p_tryAsValidatorIndex as tryAsValidatorIndex, index$p_workItem as workItem, index$p_workPackage as workPackage, index$p_workReport as workReport, index$p_workResult as workResult };
+  export type { index$p_BlockView as BlockView, index$p_CodeHash as CodeHash, index$p_CoreIndex as CoreIndex, index$p_EntropyHash as EntropyHash, index$p_Epoch as Epoch, index$p_EpochMarkerView as EpochMarkerView, index$p_ExtrinsicHash as ExtrinsicHash, index$p_ExtrinsicView as ExtrinsicView, index$p_HeaderHash as HeaderHash, index$p_HeaderView as HeaderView, index$p_PerEpochBlock as PerEpochBlock, index$p_PerValidator as PerValidator, index$p_SEGMENT_BYTES as SEGMENT_BYTES, index$p_Segment as Segment, index$p_SegmentIndex as SegmentIndex, index$p_ServiceGas as ServiceGas, index$p_ServiceId as ServiceId, index$p_StateRootHash as StateRootHash, index$p_TicketsMarkerView as TicketsMarkerView, index$p_TimeSlot as TimeSlot, index$p_ValidatorIndex as ValidatorIndex, index$p_WorkReportHash as WorkReportHash };
 }
 
 /** A type that can be read from a JSON-parsed object. */
@@ -4154,18 +4167,18 @@ declare namespace json {
 /** Given already parsed JSON, parse & validate it further to match the expected `jsonDescription` type. */
 declare function parseFromJson<T>(jsonType: unknown, jsonDescription: FromJson<T>, context?: string): T;
 
-type index$n_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
-type index$n_FromJson<T> = FromJson<T>;
-type index$n_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
-type index$n_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
-type index$n_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
-type index$n_ObjectFromJson<T> = ObjectFromJson<T>;
-type index$n_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
-import index$n_json = json;
-declare const index$n_parseFromJson: typeof parseFromJson;
-declare namespace index$n {
-  export { index$n_json as json, index$n_parseFromJson as parseFromJson };
-  export type { index$n_Builder as Builder, index$n_FromJson as FromJson, index$n_FromJsonOptional as FromJsonOptional, index$n_FromJsonPrimitive as FromJsonPrimitive, index$n_FromJsonWithParser as FromJsonWithParser, index$n_ObjectFromJson as ObjectFromJson, index$n_Parser as Parser };
+type index$o_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
+type index$o_FromJson<T> = FromJson<T>;
+type index$o_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
+type index$o_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
+type index$o_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
+type index$o_ObjectFromJson<T> = ObjectFromJson<T>;
+type index$o_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
+import index$o_json = json;
+declare const index$o_parseFromJson: typeof parseFromJson;
+declare namespace index$o {
+  export { index$o_json as json, index$o_parseFromJson as parseFromJson };
+  export type { index$o_Builder as Builder, index$o_FromJson as FromJson, index$o_FromJsonOptional as FromJsonOptional, index$o_FromJsonPrimitive as FromJsonPrimitive, index$o_FromJsonWithParser as FromJsonWithParser, index$o_ObjectFromJson as ObjectFromJson, index$o_Parser as Parser };
 }
 
 declare const getAssurancesExtrinsicFromJson: (ctx: ChainSpec) => ["array", FromJsonWithParser<unknown, AvailabilityAssurance> | FromJsonWithParser<string, AvailabilityAssurance> | FromJsonWithParser<number, AvailabilityAssurance> | ObjectFromJson<AvailabilityAssurance> | FromJsonOptional<AvailabilityAssurance> | Parser<unknown, AvailabilityAssurance[]>];
@@ -4210,23 +4223,23 @@ declare const workReportFromJson: FromJsonWithParser<unknown, WorkReport>;
 
 declare const workResultFromJson: FromJsonWithParser<unknown, WorkResult>;
 
-type index$m_JsonObject<T> = JsonObject<T>;
-declare const index$m_blockFromJson: typeof blockFromJson;
-declare const index$m_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
-import index$m_fromJson = fromJson;
-declare const index$m_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
-declare const index$m_getExtrinsicFromJson: typeof getExtrinsicFromJson;
-declare const index$m_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
-declare const index$m_headerFromJson: typeof headerFromJson;
-declare const index$m_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
-declare const index$m_refineContextFromJson: typeof refineContextFromJson;
-declare const index$m_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
-declare const index$m_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
-declare const index$m_workReportFromJson: typeof workReportFromJson;
-declare const index$m_workResultFromJson: typeof workResultFromJson;
-declare namespace index$m {
-  export { index$m_blockFromJson as blockFromJson, index$m_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$m_fromJson as fromJson, index$m_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$m_getExtrinsicFromJson as getExtrinsicFromJson, index$m_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$m_headerFromJson as headerFromJson, index$m_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$m_refineContextFromJson as refineContextFromJson, index$m_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$m_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$m_workReportFromJson as workReportFromJson, index$m_workResultFromJson as workResultFromJson };
-  export type { index$m_JsonObject as JsonObject };
+type index$n_JsonObject<T> = JsonObject<T>;
+declare const index$n_blockFromJson: typeof blockFromJson;
+declare const index$n_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
+import index$n_fromJson = fromJson;
+declare const index$n_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
+declare const index$n_getExtrinsicFromJson: typeof getExtrinsicFromJson;
+declare const index$n_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
+declare const index$n_headerFromJson: typeof headerFromJson;
+declare const index$n_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
+declare const index$n_refineContextFromJson: typeof refineContextFromJson;
+declare const index$n_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
+declare const index$n_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
+declare const index$n_workReportFromJson: typeof workReportFromJson;
+declare const index$n_workResultFromJson: typeof workResultFromJson;
+declare namespace index$n {
+  export { index$n_blockFromJson as blockFromJson, index$n_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$n_fromJson as fromJson, index$n_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$n_getExtrinsicFromJson as getExtrinsicFromJson, index$n_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$n_headerFromJson as headerFromJson, index$n_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$n_refineContextFromJson as refineContextFromJson, index$n_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$n_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$n_workReportFromJson as workReportFromJson, index$n_workResultFromJson as workResultFromJson };
+  export type { index$n_JsonObject as JsonObject };
 }
 
 declare function parseBootnode(v: string): Bootnode;
@@ -4302,29 +4315,29 @@ declare class NodeConfiguration {
 }
 declare function loadConfig(config: string[], withRelPath: (p: string) => string): NodeConfiguration;
 
-declare const index$l_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
-declare const index$l_DEV_CONFIG: typeof DEV_CONFIG;
-type index$l_JipChainSpec = JipChainSpec;
-declare const index$l_JipChainSpec: typeof JipChainSpec;
-type index$l_KnownChainSpec = KnownChainSpec;
-declare const index$l_KnownChainSpec: typeof KnownChainSpec;
-declare const index$l_NODE_DEFAULTS: typeof NODE_DEFAULTS;
-type index$l_NodeConfiguration = NodeConfiguration;
-declare const index$l_NodeConfiguration: typeof NodeConfiguration;
-declare const index$l_knownChainSpecFromJson: typeof knownChainSpecFromJson;
-declare const index$l_loadConfig: typeof loadConfig;
-declare const index$l_parseBootnode: typeof parseBootnode;
-declare namespace index$l {
+declare const index$m_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
+declare const index$m_DEV_CONFIG: typeof DEV_CONFIG;
+type index$m_JipChainSpec = JipChainSpec;
+declare const index$m_JipChainSpec: typeof JipChainSpec;
+type index$m_KnownChainSpec = KnownChainSpec;
+declare const index$m_KnownChainSpec: typeof KnownChainSpec;
+declare const index$m_NODE_DEFAULTS: typeof NODE_DEFAULTS;
+type index$m_NodeConfiguration = NodeConfiguration;
+declare const index$m_NodeConfiguration: typeof NodeConfiguration;
+declare const index$m_knownChainSpecFromJson: typeof knownChainSpecFromJson;
+declare const index$m_loadConfig: typeof loadConfig;
+declare const index$m_parseBootnode: typeof parseBootnode;
+declare namespace index$m {
   export {
-    index$l_DEFAULT_CONFIG as DEFAULT_CONFIG,
-    index$l_DEV_CONFIG as DEV_CONFIG,
-    index$l_JipChainSpec as JipChainSpec,
-    index$l_KnownChainSpec as KnownChainSpec,
-    index$l_NODE_DEFAULTS as NODE_DEFAULTS,
-    index$l_NodeConfiguration as NodeConfiguration,
-    index$l_knownChainSpecFromJson as knownChainSpecFromJson,
-    index$l_loadConfig as loadConfig,
-    index$l_parseBootnode as parseBootnode,
+    index$m_DEFAULT_CONFIG as DEFAULT_CONFIG,
+    index$m_DEV_CONFIG as DEV_CONFIG,
+    index$m_JipChainSpec as JipChainSpec,
+    index$m_KnownChainSpec as KnownChainSpec,
+    index$m_NODE_DEFAULTS as NODE_DEFAULTS,
+    index$m_NodeConfiguration as NodeConfiguration,
+    index$m_knownChainSpecFromJson as knownChainSpecFromJson,
+    index$m_loadConfig as loadConfig,
+    index$m_parseBootnode as parseBootnode,
   };
 }
 
@@ -4568,34 +4581,34 @@ declare class InMemoryTrie {
 }
 declare function findSharedPrefix(a: TruncatedStateKey, b: TruncatedStateKey): number;
 
-type index$k_BranchNode = BranchNode;
-declare const index$k_BranchNode: typeof BranchNode;
-type index$k_InMemoryTrie = InMemoryTrie;
-declare const index$k_InMemoryTrie: typeof InMemoryTrie;
-type index$k_InputKey = InputKey;
-type index$k_LeafNode = LeafNode;
-declare const index$k_LeafNode: typeof LeafNode;
-type index$k_NodeType = NodeType;
-declare const index$k_NodeType: typeof NodeType;
-type index$k_NodesDb = NodesDb;
-declare const index$k_NodesDb: typeof NodesDb;
-declare const index$k_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
-declare const index$k_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
-type index$k_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
-type index$k_TrieHasher = TrieHasher;
-type index$k_TrieNode = TrieNode;
-declare const index$k_TrieNode: typeof TrieNode;
-type index$k_TrieNodeHash = TrieNodeHash;
-type index$k_TruncatedStateKey = TruncatedStateKey;
-type index$k_ValueHash = ValueHash;
-type index$k_WriteableNodesDb = WriteableNodesDb;
-declare const index$k_WriteableNodesDb: typeof WriteableNodesDb;
-declare const index$k_findSharedPrefix: typeof findSharedPrefix;
-declare const index$k_leafComparator: typeof leafComparator;
-declare const index$k_parseInputKey: typeof parseInputKey;
-declare namespace index$k {
-  export { index$k_BranchNode as BranchNode, index$k_InMemoryTrie as InMemoryTrie, index$k_LeafNode as LeafNode, index$k_NodeType as NodeType, index$k_NodesDb as NodesDb, index$k_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$k_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$k_TrieNode as TrieNode, index$k_WriteableNodesDb as WriteableNodesDb, index$k_findSharedPrefix as findSharedPrefix, index$k_leafComparator as leafComparator, index$k_parseInputKey as parseInputKey };
-  export type { index$k_InputKey as InputKey, StateKey$1 as StateKey, index$k_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$k_TrieHasher as TrieHasher, index$k_TrieNodeHash as TrieNodeHash, index$k_TruncatedStateKey as TruncatedStateKey, index$k_ValueHash as ValueHash };
+type index$l_BranchNode = BranchNode;
+declare const index$l_BranchNode: typeof BranchNode;
+type index$l_InMemoryTrie = InMemoryTrie;
+declare const index$l_InMemoryTrie: typeof InMemoryTrie;
+type index$l_InputKey = InputKey;
+type index$l_LeafNode = LeafNode;
+declare const index$l_LeafNode: typeof LeafNode;
+type index$l_NodeType = NodeType;
+declare const index$l_NodeType: typeof NodeType;
+type index$l_NodesDb = NodesDb;
+declare const index$l_NodesDb: typeof NodesDb;
+declare const index$l_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
+declare const index$l_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
+type index$l_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
+type index$l_TrieHasher = TrieHasher;
+type index$l_TrieNode = TrieNode;
+declare const index$l_TrieNode: typeof TrieNode;
+type index$l_TrieNodeHash = TrieNodeHash;
+type index$l_TruncatedStateKey = TruncatedStateKey;
+type index$l_ValueHash = ValueHash;
+type index$l_WriteableNodesDb = WriteableNodesDb;
+declare const index$l_WriteableNodesDb: typeof WriteableNodesDb;
+declare const index$l_findSharedPrefix: typeof findSharedPrefix;
+declare const index$l_leafComparator: typeof leafComparator;
+declare const index$l_parseInputKey: typeof parseInputKey;
+declare namespace index$l {
+  export { index$l_BranchNode as BranchNode, index$l_InMemoryTrie as InMemoryTrie, index$l_LeafNode as LeafNode, index$l_NodeType as NodeType, index$l_NodesDb as NodesDb, index$l_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$l_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$l_TrieNode as TrieNode, index$l_WriteableNodesDb as WriteableNodesDb, index$l_findSharedPrefix as findSharedPrefix, index$l_leafComparator as leafComparator, index$l_parseInputKey as parseInputKey };
+  export type { index$l_InputKey as InputKey, StateKey$1 as StateKey, index$l_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$l_TrieHasher as TrieHasher, index$l_TrieNodeHash as TrieNodeHash, index$l_TruncatedStateKey as TruncatedStateKey, index$l_ValueHash as ValueHash };
 }
 
 /**
@@ -4987,13 +5000,13 @@ declare class MerkleMountainRange<H extends OpaqueHash> {
     getPeaks(): MmrPeaks<H>;
 }
 
-type index$j_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$j_MerkleMountainRange: typeof MerkleMountainRange;
-type index$j_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$j_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-declare namespace index$j {
-  export { index$j_MerkleMountainRange as MerkleMountainRange };
-  export type { index$j_MmrHasher as MmrHasher, index$j_MmrPeaks as MmrPeaks };
+type index$k_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const index$k_MerkleMountainRange: typeof MerkleMountainRange;
+type index$k_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type index$k_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+declare namespace index$k {
+  export { index$k_MerkleMountainRange as MerkleMountainRange };
+  export type { index$k_MmrHasher as MmrHasher, index$k_MmrPeaks as MmrPeaks };
 }
 
 /**
@@ -5979,114 +5992,114 @@ type FieldNames<T> = {
     [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-type index$i_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
-type index$i_AccumulationOutput = AccumulationOutput;
-declare const index$i_AccumulationOutput: typeof AccumulationOutput;
-type index$i_AccumulationQueue = AccumulationQueue;
-type index$i_AccumulationQueueView = AccumulationQueueView;
-type index$i_AuthorizationPool = AuthorizationPool;
-type index$i_AuthorizationQueue = AuthorizationQueue;
-type index$i_AvailabilityAssignment = AvailabilityAssignment;
-declare const index$i_AvailabilityAssignment: typeof AvailabilityAssignment;
-type index$i_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
-declare const index$i_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
-type index$i_BlockState = BlockState;
-declare const index$i_BlockState: typeof BlockState;
-type index$i_BlocksState = BlocksState;
-type index$i_CoreStatistics = CoreStatistics;
-declare const index$i_CoreStatistics: typeof CoreStatistics;
-type index$i_DisputesRecords = DisputesRecords;
-declare const index$i_DisputesRecords: typeof DisputesRecords;
-declare const index$i_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
-declare const index$i_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
-type index$i_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
-type index$i_EnumerableState = EnumerableState;
-type index$i_InMemoryService = InMemoryService;
-declare const index$i_InMemoryService: typeof InMemoryService;
-type index$i_InMemoryState = InMemoryState;
-declare const index$i_InMemoryState: typeof InMemoryState;
-type index$i_InMemoryStateFields = InMemoryStateFields;
-type index$i_LookupHistoryItem = LookupHistoryItem;
-declare const index$i_LookupHistoryItem: typeof LookupHistoryItem;
-type index$i_LookupHistorySlots = LookupHistorySlots;
-type index$i_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
-type index$i_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
-type index$i_NotYetAccumulatedReport = NotYetAccumulatedReport;
-declare const index$i_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
-type index$i_PerCore<T> = PerCore<T>;
-type index$i_PreimageItem = PreimageItem;
-declare const index$i_PreimageItem: typeof PreimageItem;
-type index$i_PrivilegedServices = PrivilegedServices;
-declare const index$i_PrivilegedServices: typeof PrivilegedServices;
-type index$i_RecentBlocks = RecentBlocks;
-declare const index$i_RecentBlocks: typeof RecentBlocks;
-type index$i_RecentBlocksView = RecentBlocksView;
-type index$i_RecentlyAccumulated = RecentlyAccumulated;
-type index$i_RecentlyAccumulatedView = RecentlyAccumulatedView;
-type index$i_SafroleData = SafroleData;
-declare const index$i_SafroleData: typeof SafroleData;
-type index$i_SafroleDataView = SafroleDataView;
-type index$i_SafroleSealingKeys = SafroleSealingKeys;
-type index$i_SafroleSealingKeysData = SafroleSealingKeysData;
-declare const index$i_SafroleSealingKeysData: typeof SafroleSealingKeysData;
-type index$i_SafroleSealingKeysKind = SafroleSealingKeysKind;
-declare const index$i_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
-type index$i_Service = Service;
-type index$i_ServiceAccountInfo = ServiceAccountInfo;
-declare const index$i_ServiceAccountInfo: typeof ServiceAccountInfo;
-type index$i_ServiceAccountInfoView = ServiceAccountInfoView;
-type index$i_ServiceData = ServiceData;
-type index$i_ServiceEntries = ServiceEntries;
-type index$i_ServiceStatistics = ServiceStatistics;
-declare const index$i_ServiceStatistics: typeof ServiceStatistics;
-type index$i_ServicesUpdate = ServicesUpdate;
-type index$i_State = State;
-type index$i_StateView = StateView;
-type index$i_StatisticsData = StatisticsData;
-declare const index$i_StatisticsData: typeof StatisticsData;
-type index$i_StatisticsDataView = StatisticsDataView;
-type index$i_StorageItem = StorageItem;
-declare const index$i_StorageItem: typeof StorageItem;
-type index$i_StorageKey = StorageKey;
-type index$i_UpdateError = UpdateError;
-declare const index$i_UpdateError: typeof UpdateError;
-type index$i_UpdatePreimage = UpdatePreimage;
-declare const index$i_UpdatePreimage: typeof UpdatePreimage;
-type index$i_UpdatePreimageKind = UpdatePreimageKind;
-declare const index$i_UpdatePreimageKind: typeof UpdatePreimageKind;
-type index$i_UpdateService = UpdateService;
-declare const index$i_UpdateService: typeof UpdateService;
-type index$i_UpdateServiceKind = UpdateServiceKind;
-declare const index$i_UpdateServiceKind: typeof UpdateServiceKind;
-type index$i_UpdateStorage = UpdateStorage;
-declare const index$i_UpdateStorage: typeof UpdateStorage;
-type index$i_UpdateStorageKind = UpdateStorageKind;
-declare const index$i_UpdateStorageKind: typeof UpdateStorageKind;
-type index$i_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
-type index$i_ValidatorData = ValidatorData;
-declare const index$i_ValidatorData: typeof ValidatorData;
-type index$i_ValidatorDataView = ValidatorDataView;
-type index$i_ValidatorStatistics = ValidatorStatistics;
-declare const index$i_ValidatorStatistics: typeof ValidatorStatistics;
-type index$i_WithStateView<V = StateView> = WithStateView<V>;
-declare const index$i_accumulationOutputComparator: typeof accumulationOutputComparator;
-declare const index$i_accumulationQueueCodec: typeof accumulationQueueCodec;
-declare const index$i_authPoolsCodec: typeof authPoolsCodec;
-declare const index$i_authQueuesCodec: typeof authQueuesCodec;
-declare const index$i_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
-declare const index$i_codecPerCore: typeof codecPerCore;
-declare const index$i_codecWithVersion: typeof codecWithVersion;
-declare const index$i_hashComparator: typeof hashComparator;
-declare const index$i_ignoreValueWithDefault: typeof ignoreValueWithDefault;
-declare const index$i_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
-declare const index$i_serviceDataCodec: typeof serviceDataCodec;
-declare const index$i_serviceEntriesCodec: typeof serviceEntriesCodec;
-declare const index$i_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
-declare const index$i_tryAsPerCore: typeof tryAsPerCore;
-declare const index$i_validatorsDataCodec: typeof validatorsDataCodec;
-declare namespace index$i {
-  export { index$i_AccumulationOutput as AccumulationOutput, index$i_AvailabilityAssignment as AvailabilityAssignment, index$i_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$i_BlockState as BlockState, index$i_CoreStatistics as CoreStatistics, index$i_DisputesRecords as DisputesRecords, index$i_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$i_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$i_InMemoryService as InMemoryService, index$i_InMemoryState as InMemoryState, index$i_LookupHistoryItem as LookupHistoryItem, index$i_NotYetAccumulatedReport as NotYetAccumulatedReport, index$i_PreimageItem as PreimageItem, index$i_PrivilegedServices as PrivilegedServices, index$i_RecentBlocks as RecentBlocks, index$i_SafroleData as SafroleData, index$i_SafroleSealingKeysData as SafroleSealingKeysData, index$i_SafroleSealingKeysKind as SafroleSealingKeysKind, index$i_ServiceAccountInfo as ServiceAccountInfo, index$i_ServiceStatistics as ServiceStatistics, index$i_StatisticsData as StatisticsData, index$i_StorageItem as StorageItem, index$i_UpdateError as UpdateError, index$i_UpdatePreimage as UpdatePreimage, index$i_UpdatePreimageKind as UpdatePreimageKind, index$i_UpdateService as UpdateService, index$i_UpdateServiceKind as UpdateServiceKind, index$i_UpdateStorage as UpdateStorage, index$i_UpdateStorageKind as UpdateStorageKind, index$i_ValidatorData as ValidatorData, index$i_ValidatorStatistics as ValidatorStatistics, index$i_accumulationOutputComparator as accumulationOutputComparator, index$i_accumulationQueueCodec as accumulationQueueCodec, index$i_authPoolsCodec as authPoolsCodec, index$i_authQueuesCodec as authQueuesCodec, index$i_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$i_codecPerCore as codecPerCore, index$i_codecWithVersion as codecWithVersion, index$i_hashComparator as hashComparator, index$i_ignoreValueWithDefault as ignoreValueWithDefault, index$i_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$i_serviceDataCodec as serviceDataCodec, index$i_serviceEntriesCodec as serviceEntriesCodec, index$i_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$i_tryAsPerCore as tryAsPerCore, index$i_validatorsDataCodec as validatorsDataCodec };
-  export type { index$i_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$i_AccumulationQueue as AccumulationQueue, index$i_AccumulationQueueView as AccumulationQueueView, index$i_AuthorizationPool as AuthorizationPool, index$i_AuthorizationQueue as AuthorizationQueue, index$i_AvailabilityAssignmentsView as AvailabilityAssignmentsView, index$i_BlocksState as BlocksState, index$i_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$i_EnumerableState as EnumerableState, index$i_InMemoryStateFields as InMemoryStateFields, index$i_LookupHistorySlots as LookupHistorySlots, index$i_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$i_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$i_PerCore as PerCore, index$i_RecentBlocksView as RecentBlocksView, index$i_RecentlyAccumulated as RecentlyAccumulated, index$i_RecentlyAccumulatedView as RecentlyAccumulatedView, index$i_SafroleDataView as SafroleDataView, index$i_SafroleSealingKeys as SafroleSealingKeys, index$i_Service as Service, index$i_ServiceAccountInfoView as ServiceAccountInfoView, index$i_ServiceData as ServiceData, index$i_ServiceEntries as ServiceEntries, index$i_ServicesUpdate as ServicesUpdate, index$i_State as State, index$i_StateView as StateView, index$i_StatisticsDataView as StatisticsDataView, index$i_StorageKey as StorageKey, index$i_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$i_ValidatorDataView as ValidatorDataView, index$i_WithStateView as WithStateView };
+type index$j_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
+type index$j_AccumulationOutput = AccumulationOutput;
+declare const index$j_AccumulationOutput: typeof AccumulationOutput;
+type index$j_AccumulationQueue = AccumulationQueue;
+type index$j_AccumulationQueueView = AccumulationQueueView;
+type index$j_AuthorizationPool = AuthorizationPool;
+type index$j_AuthorizationQueue = AuthorizationQueue;
+type index$j_AvailabilityAssignment = AvailabilityAssignment;
+declare const index$j_AvailabilityAssignment: typeof AvailabilityAssignment;
+type index$j_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
+declare const index$j_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
+type index$j_BlockState = BlockState;
+declare const index$j_BlockState: typeof BlockState;
+type index$j_BlocksState = BlocksState;
+type index$j_CoreStatistics = CoreStatistics;
+declare const index$j_CoreStatistics: typeof CoreStatistics;
+type index$j_DisputesRecords = DisputesRecords;
+declare const index$j_DisputesRecords: typeof DisputesRecords;
+declare const index$j_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
+declare const index$j_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
+type index$j_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
+type index$j_EnumerableState = EnumerableState;
+type index$j_InMemoryService = InMemoryService;
+declare const index$j_InMemoryService: typeof InMemoryService;
+type index$j_InMemoryState = InMemoryState;
+declare const index$j_InMemoryState: typeof InMemoryState;
+type index$j_InMemoryStateFields = InMemoryStateFields;
+type index$j_LookupHistoryItem = LookupHistoryItem;
+declare const index$j_LookupHistoryItem: typeof LookupHistoryItem;
+type index$j_LookupHistorySlots = LookupHistorySlots;
+type index$j_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
+type index$j_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
+type index$j_NotYetAccumulatedReport = NotYetAccumulatedReport;
+declare const index$j_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
+type index$j_PerCore<T> = PerCore<T>;
+type index$j_PreimageItem = PreimageItem;
+declare const index$j_PreimageItem: typeof PreimageItem;
+type index$j_PrivilegedServices = PrivilegedServices;
+declare const index$j_PrivilegedServices: typeof PrivilegedServices;
+type index$j_RecentBlocks = RecentBlocks;
+declare const index$j_RecentBlocks: typeof RecentBlocks;
+type index$j_RecentBlocksView = RecentBlocksView;
+type index$j_RecentlyAccumulated = RecentlyAccumulated;
+type index$j_RecentlyAccumulatedView = RecentlyAccumulatedView;
+type index$j_SafroleData = SafroleData;
+declare const index$j_SafroleData: typeof SafroleData;
+type index$j_SafroleDataView = SafroleDataView;
+type index$j_SafroleSealingKeys = SafroleSealingKeys;
+type index$j_SafroleSealingKeysData = SafroleSealingKeysData;
+declare const index$j_SafroleSealingKeysData: typeof SafroleSealingKeysData;
+type index$j_SafroleSealingKeysKind = SafroleSealingKeysKind;
+declare const index$j_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
+type index$j_Service = Service;
+type index$j_ServiceAccountInfo = ServiceAccountInfo;
+declare const index$j_ServiceAccountInfo: typeof ServiceAccountInfo;
+type index$j_ServiceAccountInfoView = ServiceAccountInfoView;
+type index$j_ServiceData = ServiceData;
+type index$j_ServiceEntries = ServiceEntries;
+type index$j_ServiceStatistics = ServiceStatistics;
+declare const index$j_ServiceStatistics: typeof ServiceStatistics;
+type index$j_ServicesUpdate = ServicesUpdate;
+type index$j_State = State;
+type index$j_StateView = StateView;
+type index$j_StatisticsData = StatisticsData;
+declare const index$j_StatisticsData: typeof StatisticsData;
+type index$j_StatisticsDataView = StatisticsDataView;
+type index$j_StorageItem = StorageItem;
+declare const index$j_StorageItem: typeof StorageItem;
+type index$j_StorageKey = StorageKey;
+type index$j_UpdateError = UpdateError;
+declare const index$j_UpdateError: typeof UpdateError;
+type index$j_UpdatePreimage = UpdatePreimage;
+declare const index$j_UpdatePreimage: typeof UpdatePreimage;
+type index$j_UpdatePreimageKind = UpdatePreimageKind;
+declare const index$j_UpdatePreimageKind: typeof UpdatePreimageKind;
+type index$j_UpdateService = UpdateService;
+declare const index$j_UpdateService: typeof UpdateService;
+type index$j_UpdateServiceKind = UpdateServiceKind;
+declare const index$j_UpdateServiceKind: typeof UpdateServiceKind;
+type index$j_UpdateStorage = UpdateStorage;
+declare const index$j_UpdateStorage: typeof UpdateStorage;
+type index$j_UpdateStorageKind = UpdateStorageKind;
+declare const index$j_UpdateStorageKind: typeof UpdateStorageKind;
+type index$j_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
+type index$j_ValidatorData = ValidatorData;
+declare const index$j_ValidatorData: typeof ValidatorData;
+type index$j_ValidatorDataView = ValidatorDataView;
+type index$j_ValidatorStatistics = ValidatorStatistics;
+declare const index$j_ValidatorStatistics: typeof ValidatorStatistics;
+type index$j_WithStateView<V = StateView> = WithStateView<V>;
+declare const index$j_accumulationOutputComparator: typeof accumulationOutputComparator;
+declare const index$j_accumulationQueueCodec: typeof accumulationQueueCodec;
+declare const index$j_authPoolsCodec: typeof authPoolsCodec;
+declare const index$j_authQueuesCodec: typeof authQueuesCodec;
+declare const index$j_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
+declare const index$j_codecPerCore: typeof codecPerCore;
+declare const index$j_codecWithVersion: typeof codecWithVersion;
+declare const index$j_hashComparator: typeof hashComparator;
+declare const index$j_ignoreValueWithDefault: typeof ignoreValueWithDefault;
+declare const index$j_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
+declare const index$j_serviceDataCodec: typeof serviceDataCodec;
+declare const index$j_serviceEntriesCodec: typeof serviceEntriesCodec;
+declare const index$j_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
+declare const index$j_tryAsPerCore: typeof tryAsPerCore;
+declare const index$j_validatorsDataCodec: typeof validatorsDataCodec;
+declare namespace index$j {
+  export { index$j_AccumulationOutput as AccumulationOutput, index$j_AvailabilityAssignment as AvailabilityAssignment, index$j_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$j_BlockState as BlockState, index$j_CoreStatistics as CoreStatistics, index$j_DisputesRecords as DisputesRecords, index$j_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$j_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$j_InMemoryService as InMemoryService, index$j_InMemoryState as InMemoryState, index$j_LookupHistoryItem as LookupHistoryItem, index$j_NotYetAccumulatedReport as NotYetAccumulatedReport, index$j_PreimageItem as PreimageItem, index$j_PrivilegedServices as PrivilegedServices, index$j_RecentBlocks as RecentBlocks, index$j_SafroleData as SafroleData, index$j_SafroleSealingKeysData as SafroleSealingKeysData, index$j_SafroleSealingKeysKind as SafroleSealingKeysKind, index$j_ServiceAccountInfo as ServiceAccountInfo, index$j_ServiceStatistics as ServiceStatistics, index$j_StatisticsData as StatisticsData, index$j_StorageItem as StorageItem, index$j_UpdateError as UpdateError, index$j_UpdatePreimage as UpdatePreimage, index$j_UpdatePreimageKind as UpdatePreimageKind, index$j_UpdateService as UpdateService, index$j_UpdateServiceKind as UpdateServiceKind, index$j_UpdateStorage as UpdateStorage, index$j_UpdateStorageKind as UpdateStorageKind, index$j_ValidatorData as ValidatorData, index$j_ValidatorStatistics as ValidatorStatistics, index$j_accumulationOutputComparator as accumulationOutputComparator, index$j_accumulationQueueCodec as accumulationQueueCodec, index$j_authPoolsCodec as authPoolsCodec, index$j_authQueuesCodec as authQueuesCodec, index$j_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$j_codecPerCore as codecPerCore, index$j_codecWithVersion as codecWithVersion, index$j_hashComparator as hashComparator, index$j_ignoreValueWithDefault as ignoreValueWithDefault, index$j_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$j_serviceDataCodec as serviceDataCodec, index$j_serviceEntriesCodec as serviceEntriesCodec, index$j_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$j_tryAsPerCore as tryAsPerCore, index$j_validatorsDataCodec as validatorsDataCodec };
+  export type { index$j_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$j_AccumulationQueue as AccumulationQueue, index$j_AccumulationQueueView as AccumulationQueueView, index$j_AuthorizationPool as AuthorizationPool, index$j_AuthorizationQueue as AuthorizationQueue, index$j_AvailabilityAssignmentsView as AvailabilityAssignmentsView, index$j_BlocksState as BlocksState, index$j_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$j_EnumerableState as EnumerableState, index$j_InMemoryStateFields as InMemoryStateFields, index$j_LookupHistorySlots as LookupHistorySlots, index$j_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$j_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$j_PerCore as PerCore, index$j_RecentBlocksView as RecentBlocksView, index$j_RecentlyAccumulated as RecentlyAccumulated, index$j_RecentlyAccumulatedView as RecentlyAccumulatedView, index$j_SafroleDataView as SafroleDataView, index$j_SafroleSealingKeys as SafroleSealingKeys, index$j_Service as Service, index$j_ServiceAccountInfoView as ServiceAccountInfoView, index$j_ServiceData as ServiceData, index$j_ServiceEntries as ServiceEntries, index$j_ServicesUpdate as ServicesUpdate, index$j_State as State, index$j_StateView as StateView, index$j_StatisticsDataView as StatisticsDataView, index$j_StorageKey as StorageKey, index$j_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$j_ValidatorDataView as ValidatorDataView, index$j_WithStateView as WithStateView };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -6418,32 +6431,32 @@ declare const dumpCodec: Descriptor<BytesBlob, BytesBlob>;
  *        hashmap of `key -> value` entries.
  */
 
-type index$h_SerializedService = SerializedService;
-declare const index$h_SerializedService: typeof SerializedService;
-type index$h_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
-declare const index$h_SerializedState: typeof SerializedState;
-type index$h_SerializedStateBackend = SerializedStateBackend;
-type index$h_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
-declare const index$h_SerializedStateView: typeof SerializedStateView;
-type index$h_StateCodec<T, V = T> = StateCodec<T, V>;
-type index$h_StateEntries = StateEntries;
-declare const index$h_StateEntries: typeof StateEntries;
-type index$h_StateEntryUpdate = StateEntryUpdate;
-type index$h_StateEntryUpdateAction = StateEntryUpdateAction;
-declare const index$h_StateEntryUpdateAction: typeof StateEntryUpdateAction;
-type index$h_StateKey = StateKey;
-type index$h_StateKeyIdx = StateKeyIdx;
-declare const index$h_StateKeyIdx: typeof StateKeyIdx;
-declare const index$h_binaryMerkleization: typeof binaryMerkleization;
-declare const index$h_dumpCodec: typeof dumpCodec;
-declare const index$h_legacyServiceNested: typeof legacyServiceNested;
-declare const index$h_loadState: typeof loadState;
-import index$h_serialize = serialize;
-declare const index$h_serializeStateUpdate: typeof serializeStateUpdate;
-import index$h_stateKeys = stateKeys;
-declare namespace index$h {
-  export { index$h_SerializedService as SerializedService, index$h_SerializedState as SerializedState, index$h_SerializedStateView as SerializedStateView, index$h_StateEntries as StateEntries, index$h_StateEntryUpdateAction as StateEntryUpdateAction, index$h_StateKeyIdx as StateKeyIdx, index$h_binaryMerkleization as binaryMerkleization, index$h_dumpCodec as dumpCodec, index$h_legacyServiceNested as legacyServiceNested, index$h_loadState as loadState, index$h_serialize as serialize, index$h_serializeStateUpdate as serializeStateUpdate, index$h_stateKeys as stateKeys };
-  export type { index$h_SerializedStateBackend as SerializedStateBackend, index$h_StateCodec as StateCodec, index$h_StateEntryUpdate as StateEntryUpdate, index$h_StateKey as StateKey };
+type index$i_SerializedService = SerializedService;
+declare const index$i_SerializedService: typeof SerializedService;
+type index$i_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
+declare const index$i_SerializedState: typeof SerializedState;
+type index$i_SerializedStateBackend = SerializedStateBackend;
+type index$i_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
+declare const index$i_SerializedStateView: typeof SerializedStateView;
+type index$i_StateCodec<T, V = T> = StateCodec<T, V>;
+type index$i_StateEntries = StateEntries;
+declare const index$i_StateEntries: typeof StateEntries;
+type index$i_StateEntryUpdate = StateEntryUpdate;
+type index$i_StateEntryUpdateAction = StateEntryUpdateAction;
+declare const index$i_StateEntryUpdateAction: typeof StateEntryUpdateAction;
+type index$i_StateKey = StateKey;
+type index$i_StateKeyIdx = StateKeyIdx;
+declare const index$i_StateKeyIdx: typeof StateKeyIdx;
+declare const index$i_binaryMerkleization: typeof binaryMerkleization;
+declare const index$i_dumpCodec: typeof dumpCodec;
+declare const index$i_legacyServiceNested: typeof legacyServiceNested;
+declare const index$i_loadState: typeof loadState;
+import index$i_serialize = serialize;
+declare const index$i_serializeStateUpdate: typeof serializeStateUpdate;
+import index$i_stateKeys = stateKeys;
+declare namespace index$i {
+  export { index$i_SerializedService as SerializedService, index$i_SerializedState as SerializedState, index$i_SerializedStateView as SerializedStateView, index$i_StateEntries as StateEntries, index$i_StateEntryUpdateAction as StateEntryUpdateAction, index$i_StateKeyIdx as StateKeyIdx, index$i_binaryMerkleization as binaryMerkleization, index$i_dumpCodec as dumpCodec, index$i_legacyServiceNested as legacyServiceNested, index$i_loadState as loadState, index$i_serialize as serialize, index$i_serializeStateUpdate as serializeStateUpdate, index$i_stateKeys as stateKeys };
+  export type { index$i_SerializedStateBackend as SerializedStateBackend, index$i_StateCodec as StateCodec, index$i_StateEntryUpdate as StateEntryUpdate, index$i_StateKey as StateKey };
 }
 
 /** Error during `LeafDb` creation. */
@@ -6568,28 +6581,28 @@ declare class InMemorySerializedStates implements StatesDb<SerializedState<LeafD
     close(): Promise<void>;
 }
 
-type index$g_BlocksDb = BlocksDb;
-type index$g_InMemoryBlocks = InMemoryBlocks;
-declare const index$g_InMemoryBlocks: typeof InMemoryBlocks;
-type index$g_InMemorySerializedStates = InMemorySerializedStates;
-declare const index$g_InMemorySerializedStates: typeof InMemorySerializedStates;
-type index$g_InMemoryStates = InMemoryStates;
-declare const index$g_InMemoryStates: typeof InMemoryStates;
-type index$g_InitStatesDb<T = State> = InitStatesDb<T>;
-type index$g_LeafDb = LeafDb;
-declare const index$g_LeafDb: typeof LeafDb;
-type index$g_LeafDbError = LeafDbError;
-declare const index$g_LeafDbError: typeof LeafDbError;
-type index$g_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
-type index$g_SerializedStatesDb = SerializedStatesDb;
-type index$g_StateUpdateError = StateUpdateError;
-declare const index$g_StateUpdateError: typeof StateUpdateError;
-type index$g_StatesDb<T extends State = State> = StatesDb<T>;
-type index$g_ValuesDb = ValuesDb;
-declare const index$g_updateLeafs: typeof updateLeafs;
-declare namespace index$g {
-  export { index$g_InMemoryBlocks as InMemoryBlocks, index$g_InMemorySerializedStates as InMemorySerializedStates, index$g_InMemoryStates as InMemoryStates, index$g_LeafDb as LeafDb, index$g_LeafDbError as LeafDbError, index$g_StateUpdateError as StateUpdateError, index$g_updateLeafs as updateLeafs };
-  export type { index$g_BlocksDb as BlocksDb, index$g_InitStatesDb as InitStatesDb, index$g_RootDb as RootDb, index$g_SerializedStatesDb as SerializedStatesDb, index$g_StatesDb as StatesDb, index$g_ValuesDb as ValuesDb };
+type index$h_BlocksDb = BlocksDb;
+type index$h_InMemoryBlocks = InMemoryBlocks;
+declare const index$h_InMemoryBlocks: typeof InMemoryBlocks;
+type index$h_InMemorySerializedStates = InMemorySerializedStates;
+declare const index$h_InMemorySerializedStates: typeof InMemorySerializedStates;
+type index$h_InMemoryStates = InMemoryStates;
+declare const index$h_InMemoryStates: typeof InMemoryStates;
+type index$h_InitStatesDb<T = State> = InitStatesDb<T>;
+type index$h_LeafDb = LeafDb;
+declare const index$h_LeafDb: typeof LeafDb;
+type index$h_LeafDbError = LeafDbError;
+declare const index$h_LeafDbError: typeof LeafDbError;
+type index$h_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
+type index$h_SerializedStatesDb = SerializedStatesDb;
+type index$h_StateUpdateError = StateUpdateError;
+declare const index$h_StateUpdateError: typeof StateUpdateError;
+type index$h_StatesDb<T extends State = State> = StatesDb<T>;
+type index$h_ValuesDb = ValuesDb;
+declare const index$h_updateLeafs: typeof updateLeafs;
+declare namespace index$h {
+  export { index$h_InMemoryBlocks as InMemoryBlocks, index$h_InMemorySerializedStates as InMemorySerializedStates, index$h_InMemoryStates as InMemoryStates, index$h_LeafDb as LeafDb, index$h_LeafDbError as LeafDbError, index$h_StateUpdateError as StateUpdateError, index$h_updateLeafs as updateLeafs };
+  export type { index$h_BlocksDb as BlocksDb, index$h_InitStatesDb as InitStatesDb, index$h_RootDb as RootDb, index$h_SerializedStatesDb as SerializedStatesDb, index$h_StatesDb as StatesDb, index$h_ValuesDb as ValuesDb };
 }
 
 /**
@@ -6732,29 +6745,29 @@ declare function chunksToShards(spec: ChainSpec, chunks: FixedSizeArray<BytesBlo
 
 declare const initEc: () => Promise<void>;
 
-declare const index$f_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
-type index$f_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
-type index$f_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
-type index$f_PIECE_SIZE = PIECE_SIZE;
-type index$f_POINT_LENGTH = POINT_LENGTH;
-declare const index$f_checkConsistency: typeof checkConsistency;
-declare const index$f_chunkingFunction: typeof chunkingFunction;
-declare const index$f_chunksToShards: typeof chunksToShards;
-declare const index$f_decodeData: typeof decodeData;
-declare const index$f_decodeDataAndTrim: typeof decodeDataAndTrim;
-declare const index$f_decodePiece: typeof decodePiece;
-declare const index$f_encodePoints: typeof encodePoints;
-declare const index$f_initEc: typeof initEc;
-declare const index$f_join: typeof join;
-declare const index$f_lace: typeof lace;
-declare const index$f_padAndEncodeData: typeof padAndEncodeData;
-declare const index$f_shardsToChunks: typeof shardsToChunks;
-declare const index$f_split: typeof split;
-declare const index$f_transpose: typeof transpose;
-declare const index$f_unzip: typeof unzip;
-declare namespace index$f {
-  export { index$f_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$f_checkConsistency as checkConsistency, index$f_chunkingFunction as chunkingFunction, index$f_chunksToShards as chunksToShards, index$f_decodeData as decodeData, index$f_decodeDataAndTrim as decodeDataAndTrim, index$f_decodePiece as decodePiece, index$f_encodePoints as encodePoints, index$f_initEc as initEc, index$f_join as join, index$f_lace as lace, index$f_padAndEncodeData as padAndEncodeData, index$f_shardsToChunks as shardsToChunks, index$f_split as split, index$f_transpose as transpose, index$f_unzip as unzip };
-  export type { index$f_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$f_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$f_PIECE_SIZE as PIECE_SIZE, index$f_POINT_LENGTH as POINT_LENGTH };
+declare const index$g_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
+type index$g_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
+type index$g_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
+type index$g_PIECE_SIZE = PIECE_SIZE;
+type index$g_POINT_LENGTH = POINT_LENGTH;
+declare const index$g_checkConsistency: typeof checkConsistency;
+declare const index$g_chunkingFunction: typeof chunkingFunction;
+declare const index$g_chunksToShards: typeof chunksToShards;
+declare const index$g_decodeData: typeof decodeData;
+declare const index$g_decodeDataAndTrim: typeof decodeDataAndTrim;
+declare const index$g_decodePiece: typeof decodePiece;
+declare const index$g_encodePoints: typeof encodePoints;
+declare const index$g_initEc: typeof initEc;
+declare const index$g_join: typeof join;
+declare const index$g_lace: typeof lace;
+declare const index$g_padAndEncodeData: typeof padAndEncodeData;
+declare const index$g_shardsToChunks: typeof shardsToChunks;
+declare const index$g_split: typeof split;
+declare const index$g_transpose: typeof transpose;
+declare const index$g_unzip: typeof unzip;
+declare namespace index$g {
+  export { index$g_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$g_checkConsistency as checkConsistency, index$g_chunkingFunction as chunkingFunction, index$g_chunksToShards as chunksToShards, index$g_decodeData as decodeData, index$g_decodeDataAndTrim as decodeDataAndTrim, index$g_decodePiece as decodePiece, index$g_encodePoints as encodePoints, index$g_initEc as initEc, index$g_join as join, index$g_lace as lace, index$g_padAndEncodeData as padAndEncodeData, index$g_shardsToChunks as shardsToChunks, index$g_split as split, index$g_transpose as transpose, index$g_unzip as unzip };
+  export type { index$g_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$g_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$g_PIECE_SIZE as PIECE_SIZE, index$g_POINT_LENGTH as POINT_LENGTH };
 }
 
 /** A per-client handler of incoming socket messages. */
@@ -7030,45 +7043,45 @@ declare class FuzzTarget implements IpcHandler {
     hasFeature(feature: number): boolean;
 }
 
-type index$e_Ancestry = Ancestry;
-type index$e_AncestryItem = AncestryItem;
-declare const index$e_AncestryItem: typeof AncestryItem;
-type index$e_ErrorMessage = ErrorMessage;
-declare const index$e_ErrorMessage: typeof ErrorMessage;
-type index$e_Features = Features;
-declare const index$e_Features: typeof Features;
-type index$e_FuzzMessageHandler = FuzzMessageHandler;
-type index$e_FuzzTarget = FuzzTarget;
-declare const index$e_FuzzTarget: typeof FuzzTarget;
-type index$e_GetState = GetState;
-type index$e_Initialize = Initialize;
-declare const index$e_Initialize: typeof Initialize;
-type index$e_KeyValue = KeyValue;
-declare const index$e_KeyValue: typeof KeyValue;
-type index$e_Message = Message;
-type index$e_MessageData = MessageData;
-type index$e_MessageType = MessageType;
-declare const index$e_MessageType: typeof MessageType;
-type index$e_PeerInfo = PeerInfo;
-declare const index$e_PeerInfo: typeof PeerInfo;
-type index$e_StateRoot = StateRoot;
-type index$e_Version = Version;
-declare const index$e_Version: typeof Version;
-declare const index$e_ancestryCodec: typeof ancestryCodec;
-declare const index$e_getStateCodec: typeof getStateCodec;
-declare const index$e_messageCodec: typeof messageCodec;
-declare const index$e_stateCodec: typeof stateCodec;
-declare const index$e_stateRootCodec: typeof stateRootCodec;
-declare namespace index$e {
-  export { index$e_AncestryItem as AncestryItem, index$e_ErrorMessage as ErrorMessage, index$e_Features as Features, index$e_FuzzTarget as FuzzTarget, index$e_Initialize as Initialize, index$e_KeyValue as KeyValue, index$e_MessageType as MessageType, index$e_PeerInfo as PeerInfo, index$e_Version as Version, index$e_ancestryCodec as ancestryCodec, index$e_getStateCodec as getStateCodec, index$e_messageCodec as messageCodec, index$e_stateCodec as stateCodec, index$e_stateRootCodec as stateRootCodec };
-  export type { index$e_Ancestry as Ancestry, index$e_FuzzMessageHandler as FuzzMessageHandler, index$e_GetState as GetState, index$e_Message as Message, index$e_MessageData as MessageData, index$e_StateRoot as StateRoot };
+type index$f_Ancestry = Ancestry;
+type index$f_AncestryItem = AncestryItem;
+declare const index$f_AncestryItem: typeof AncestryItem;
+type index$f_ErrorMessage = ErrorMessage;
+declare const index$f_ErrorMessage: typeof ErrorMessage;
+type index$f_Features = Features;
+declare const index$f_Features: typeof Features;
+type index$f_FuzzMessageHandler = FuzzMessageHandler;
+type index$f_FuzzTarget = FuzzTarget;
+declare const index$f_FuzzTarget: typeof FuzzTarget;
+type index$f_GetState = GetState;
+type index$f_Initialize = Initialize;
+declare const index$f_Initialize: typeof Initialize;
+type index$f_KeyValue = KeyValue;
+declare const index$f_KeyValue: typeof KeyValue;
+type index$f_Message = Message;
+type index$f_MessageData = MessageData;
+type index$f_MessageType = MessageType;
+declare const index$f_MessageType: typeof MessageType;
+type index$f_PeerInfo = PeerInfo;
+declare const index$f_PeerInfo: typeof PeerInfo;
+type index$f_StateRoot = StateRoot;
+type index$f_Version = Version;
+declare const index$f_Version: typeof Version;
+declare const index$f_ancestryCodec: typeof ancestryCodec;
+declare const index$f_getStateCodec: typeof getStateCodec;
+declare const index$f_messageCodec: typeof messageCodec;
+declare const index$f_stateCodec: typeof stateCodec;
+declare const index$f_stateRootCodec: typeof stateRootCodec;
+declare namespace index$f {
+  export { index$f_AncestryItem as AncestryItem, index$f_ErrorMessage as ErrorMessage, index$f_Features as Features, index$f_FuzzTarget as FuzzTarget, index$f_Initialize as Initialize, index$f_KeyValue as KeyValue, index$f_MessageType as MessageType, index$f_PeerInfo as PeerInfo, index$f_Version as Version, index$f_ancestryCodec as ancestryCodec, index$f_getStateCodec as getStateCodec, index$f_messageCodec as messageCodec, index$f_stateCodec as stateCodec, index$f_stateRootCodec as stateRootCodec };
+  export type { index$f_Ancestry as Ancestry, index$f_FuzzMessageHandler as FuzzMessageHandler, index$f_GetState as GetState, index$f_Message as Message, index$f_MessageData as MessageData, index$f_StateRoot as StateRoot };
 }
 
-type index$d_IpcHandler = IpcHandler;
-type index$d_IpcSender = IpcSender;
-declare namespace index$d {
-  export { index$e as v1 };
-  export type { index$d_IpcHandler as IpcHandler, index$d_IpcSender as IpcSender };
+type index$e_IpcHandler = IpcHandler;
+type index$e_IpcSender = IpcSender;
+declare namespace index$e {
+  export { index$f as v1 };
+  export type { index$e_IpcHandler as IpcHandler, index$e_IpcSender as IpcSender };
 }
 
 /**
@@ -7200,6 +7213,8 @@ declare class Channel {
 
 /** Standardized worker config. */
 interface WorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> {
+    /** Node name. */
+    readonly nodeName: string;
     /** Chain spec. */
     readonly chainSpec: ChainSpec;
     /** Worker parameters. */
@@ -7213,11 +7228,13 @@ interface WorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> {
  * Worker config with in-thread database.
  */
 declare class DirectWorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> implements WorkerConfig<TParams, TBlocks, TStates> {
+    readonly nodeName: string;
     readonly chainSpec: ChainSpec;
     readonly workerParams: TParams;
     private readonly blocksDb;
     private readonly statesDb;
-    static new<T, B, S>({ chainSpec, blocksDb, statesDb, params, }: {
+    static new<T, B, S>({ nodeName, chainSpec, blocksDb, statesDb, params, }: {
+        nodeName: string;
         chainSpec: ChainSpec;
         blocksDb: B;
         statesDb: S;
@@ -7238,35 +7255,35 @@ declare function startSameThread<To, From>(protocol: LousyProtocol<To, From>): {
     internal: Internal<LousyProtocol<To, From>>;
 };
 
-type index$c_Api<T> = Api<T>;
-type index$c_Channel = Channel;
-declare const index$c_Channel: typeof Channel;
-type index$c_Destroy = Destroy;
-type index$c_DirectPort = DirectPort;
-declare const index$c_DirectPort: typeof DirectPort;
-type index$c_DirectWorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = DirectWorkerConfig<TParams, TBlocks, TStates>;
-declare const index$c_DirectWorkerConfig: typeof DirectWorkerConfig;
-type index$c_Envelope<T> = Envelope<T>;
-type index$c_Handler<Req, Res> = Handler<Req, Res>;
-type index$c_HandlerKey<K> = HandlerKey<K>;
-type index$c_Handlers<In> = Handlers<In>;
-type index$c_Internal<T> = Internal<T>;
-type index$c_LousyProtocol<To, From> = LousyProtocol<To, From>;
-type index$c_MessageCodecs<Req, Res> = MessageCodecs<Req, Res>;
-type index$c_MessagesList<T> = MessagesList<T>;
-type index$c_Port = Port;
-type index$c_Protocol<To, From> = Protocol<To, From>;
-type index$c_Rx<To, From> = Rx<To, From>;
-type index$c_Sender<Req, Res> = Sender<Req, Res>;
-type index$c_SenderKey<K> = SenderKey<K>;
-type index$c_Senders<Out> = Senders<Out>;
-type index$c_Tx<To, From> = Tx<To, From>;
-type index$c_WorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = WorkerConfig<TParams, TBlocks, TStates>;
-declare const index$c_createProtocol: typeof createProtocol;
-declare const index$c_startSameThread: typeof startSameThread;
-declare namespace index$c {
-  export { index$c_Channel as Channel, index$c_DirectPort as DirectPort, index$c_DirectWorkerConfig as DirectWorkerConfig, index$c_createProtocol as createProtocol, index$c_startSameThread as startSameThread };
-  export type { index$c_Api as Api, index$c_Destroy as Destroy, index$c_Envelope as Envelope, index$c_Handler as Handler, index$c_HandlerKey as HandlerKey, index$c_Handlers as Handlers, index$c_Internal as Internal, index$c_LousyProtocol as LousyProtocol, index$c_MessageCodecs as MessageCodecs, index$c_MessagesList as MessagesList, index$c_Port as Port, index$c_Protocol as Protocol, index$c_Rx as Rx, index$c_Sender as Sender, index$c_SenderKey as SenderKey, index$c_Senders as Senders, index$c_Tx as Tx, index$c_WorkerConfig as WorkerConfig };
+type index$d_Api<T> = Api<T>;
+type index$d_Channel = Channel;
+declare const index$d_Channel: typeof Channel;
+type index$d_Destroy = Destroy;
+type index$d_DirectPort = DirectPort;
+declare const index$d_DirectPort: typeof DirectPort;
+type index$d_DirectWorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = DirectWorkerConfig<TParams, TBlocks, TStates>;
+declare const index$d_DirectWorkerConfig: typeof DirectWorkerConfig;
+type index$d_Envelope<T> = Envelope<T>;
+type index$d_Handler<Req, Res> = Handler<Req, Res>;
+type index$d_HandlerKey<K> = HandlerKey<K>;
+type index$d_Handlers<In> = Handlers<In>;
+type index$d_Internal<T> = Internal<T>;
+type index$d_LousyProtocol<To, From> = LousyProtocol<To, From>;
+type index$d_MessageCodecs<Req, Res> = MessageCodecs<Req, Res>;
+type index$d_MessagesList<T> = MessagesList<T>;
+type index$d_Port = Port;
+type index$d_Protocol<To, From> = Protocol<To, From>;
+type index$d_Rx<To, From> = Rx<To, From>;
+type index$d_Sender<Req, Res> = Sender<Req, Res>;
+type index$d_SenderKey<K> = SenderKey<K>;
+type index$d_Senders<Out> = Senders<Out>;
+type index$d_Tx<To, From> = Tx<To, From>;
+type index$d_WorkerConfig<TParams = void, TBlocks = BlocksDb, TStates = StatesDb> = WorkerConfig<TParams, TBlocks, TStates>;
+declare const index$d_createProtocol: typeof createProtocol;
+declare const index$d_startSameThread: typeof startSameThread;
+declare namespace index$d {
+  export { index$d_Channel as Channel, index$d_DirectPort as DirectPort, index$d_DirectWorkerConfig as DirectWorkerConfig, index$d_createProtocol as createProtocol, index$d_startSameThread as startSameThread };
+  export type { index$d_Api as Api, index$d_Destroy as Destroy, index$d_Envelope as Envelope, index$d_Handler as Handler, index$d_HandlerKey as HandlerKey, index$d_Handlers as Handlers, index$d_Internal as Internal, index$d_LousyProtocol as LousyProtocol, index$d_MessageCodecs as MessageCodecs, index$d_MessagesList as MessagesList, index$d_Port as Port, index$d_Protocol as Protocol, index$d_Rx as Rx, index$d_Sender as Sender, index$d_SenderKey as SenderKey, index$d_Senders as Senders, index$d_Tx as Tx, index$d_WorkerConfig as WorkerConfig };
 }
 
 declare enum Level {
@@ -7344,16 +7361,16 @@ declare class Logger {
     error(strings: TemplateStringsArray, ...data: unknown[]): void;
 }
 
-type index$b_Level = Level;
-declare const index$b_Level: typeof Level;
-type index$b_Logger = Logger;
-declare const index$b_Logger: typeof Logger;
-declare const index$b_parseLoggerOptions: typeof parseLoggerOptions;
-declare namespace index$b {
+type index$c_Level = Level;
+declare const index$c_Level: typeof Level;
+type index$c_Logger = Logger;
+declare const index$c_Logger: typeof Logger;
+declare const index$c_parseLoggerOptions: typeof parseLoggerOptions;
+declare namespace index$c {
   export {
-    index$b_Level as Level,
-    index$b_Logger as Logger,
-    index$b_parseLoggerOptions as parseLoggerOptions,
+    index$c_Level as Level,
+    index$c_Logger as Logger,
+    index$c_parseLoggerOptions as parseLoggerOptions,
   };
 }
 
@@ -7583,6 +7600,12 @@ type BigGas = Opaque<U64, "BigGas[U64]">;
 type SmallGas = Opaque<U32, "SmallGas[U32]">;
 /** Gas measuring type. Can be either U64 or U32 for performance reasons. */
 type Gas = BigGas | SmallGas;
+/** Attempt to convert given number into U32 gas representation. */
+declare const tryAsSmallGas: (v: number) => SmallGas;
+/** Attempt to convert given number into U64 gas representation. */
+declare const tryAsBigGas: (v: number | bigint) => BigGas;
+/** Attempt to convert given number into gas. */
+declare const tryAsGas: (v: number | bigint) => Gas;
 /** An abstraction over gas counter.
  *
  * It can be optimized to use numbers instead of bigint in case of small gas.
@@ -7617,9 +7640,12 @@ interface IGasCounter {
     used(): Gas;
 }
 
+declare const MAX_MEMORY_INDEX = 4294967295;
+declare const MEMORY_SIZE: number;
 type PageFault$1 = {
     address: U32;
 };
+declare function getPageStartAddress(address: U32): U32;
 /** Allows store and read segments of memory. */
 interface IMemory {
     /** Store bytes into memory at given address. */
@@ -7628,6 +7654,8 @@ interface IMemory {
     read(address: U32, result: Uint8Array): Result<OK, PageFault$1>;
 }
 
+declare const NO_OF_REGISTERS = 13;
+declare const REGISTER_BYTE_SIZE = 8;
 /** Allow to set and get all registers encoded into little-endian bytes. */
 interface IRegisters {
     /**
@@ -7683,7 +7711,30 @@ interface IPvmInterpreter {
     getExitParam(): U32 | null;
 }
 
+type index$b_BigGas = BigGas;
+type index$b_Gas = Gas;
+type index$b_IGasCounter = IGasCounter;
+type index$b_IMemory = IMemory;
+type index$b_IPvmInterpreter = IPvmInterpreter;
+type index$b_IRegisters = IRegisters;
+declare const index$b_MAX_MEMORY_INDEX: typeof MAX_MEMORY_INDEX;
+declare const index$b_MEMORY_SIZE: typeof MEMORY_SIZE;
+declare const index$b_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
+declare const index$b_REGISTER_BYTE_SIZE: typeof REGISTER_BYTE_SIZE;
+type index$b_SmallGas = SmallGas;
+type index$b_Status = Status;
+declare const index$b_Status: typeof Status;
+declare const index$b_getPageStartAddress: typeof getPageStartAddress;
+declare const index$b_tryAsBigGas: typeof tryAsBigGas;
+declare const index$b_tryAsGas: typeof tryAsGas;
+declare const index$b_tryAsSmallGas: typeof tryAsSmallGas;
+declare namespace index$b {
+  export { index$b_MAX_MEMORY_INDEX as MAX_MEMORY_INDEX, index$b_MEMORY_SIZE as MEMORY_SIZE, index$b_NO_OF_REGISTERS as NO_OF_REGISTERS, index$b_REGISTER_BYTE_SIZE as REGISTER_BYTE_SIZE, index$b_Status as Status, index$b_getPageStartAddress as getPageStartAddress, index$b_tryAsBigGas as tryAsBigGas, index$b_tryAsGas as tryAsGas, index$b_tryAsSmallGas as tryAsSmallGas };
+  export type { index$b_BigGas as BigGas, index$b_Gas as Gas, index$b_IGasCounter as IGasCounter, index$b_IMemory as IMemory, index$b_IPvmInterpreter as IPvmInterpreter, index$b_IRegisters as IRegisters, PageFault$1 as PageFault, index$b_SmallGas as SmallGas };
+}
+
 type RegisterIndex = Opaque<number, "register index">;
+declare const tryAsRegisterIndex: (index: number) => RegisterIndex;
 declare class Registers implements IRegisters {
     private readonly bytes;
     private asSigned;
@@ -7705,6 +7756,7 @@ declare class Registers implements IRegisters {
     setI64(registerIndex: number, value: bigint): void;
     getAllU64(): BigUint64Array<ArrayBufferLike>;
 }
+declare function signExtend32To64(value: number | bigint): bigint;
 
 declare class HostCallMemory {
     private readonly memory;
@@ -7836,9 +7888,57 @@ declare namespace index$a {
   export type { index$a_HostCallHandler as HostCallHandler };
 }
 
+declare class JumpTable {
+    private indices;
+    constructor(itemByteLength: number, bytes: Uint8Array);
+    private decodeNext;
+    hasIndex(index: number): boolean;
+    getDestination(index: number): number;
+    static empty(): JumpTable;
+    getSize(): number;
+    copyFrom(jt: JumpTable): void;
+}
+
+/**
+ * Mask class is an implementation of skip function defined in GP.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
+ */
+declare class Mask {
+    /**
+     * The lookup table will have `0` at the index which corresponds to an instruction on the same index in the bytecode.
+     * In case the value is non-zero it signifies the offset to the index with next instruction.
+     *
+     * Example:
+     * ```
+     * 0..1..2..3..4..5..6..7..8..9 # Indices
+     * 0..2..1..0..1..0..3..2..1..0 # lookupTable forward values
+     * ```
+     * There are instructions at indices `0, 3, 5, 9`.
+     */
+    private lookupTableForward;
+    constructor(mask: BitVec);
+    isInstruction(index: number): boolean;
+    getNoOfBytesToNextInstruction(index: number): number;
+    private buildLookupTableForward;
+    static empty(): Mask;
+}
+
 declare enum ProgramDecoderError {
     InvalidProgramError = 0
 }
+declare class ProgramDecoder {
+    private code;
+    private mask;
+    private jumpTable;
+    constructor(rawProgram: Uint8Array);
+    private decodeProgram;
+    getMask(): Mask;
+    getCode(): Uint8Array<ArrayBufferLike>;
+    getJumpTable(): JumpTable;
+    /** https://graypaper.fluffylabs.dev/#/68eaa1f/23f400234701?v=0.6.4 */
+    static deblob(program: Uint8Array): Result<ProgramDecoder, ProgramDecoderError>;
+}
 
 /**
  * Program counter is a 64-bit unsigned integer that points to the next instruction
@@ -9355,6 +9455,7 @@ declare class Importer {
     private readonly stf;
     private readonly state;
     private currentHash;
+    private readonly metrics;
     constructor(spec: ChainSpec, pvm: PvmBackend, hasher: TransitionHasher, logger: Logger, blocks: BlocksDb, states: StatesDb<SerializedState<LeafDb>>);
     /** Do some extra work for preparation for the next epoch. */
     prepareForNextEpoch(): Promise<void>;
@@ -9729,6 +9830,20 @@ declare function createImporter(config: Config): Promise<{
  */
 declare function main(config: Config, comms: ImporterInternal): Promise<void>;
 
+/**
+ * Block importer metrics for JAM implementation.
+ *
+ * https://github.com/polkadot-fellows/JIPs/blob/main/JIP-3.md#block-authoringimporting-events
+ */
+declare function createMetrics(): {
+    recordBlockImportComplete(totalDurationMs: number, success: boolean): void;
+    recordBlockImportingStarted(slot: number): void;
+    recordBlockVerificationFailed(reason: string): void;
+    recordBlockVerified(durationMs: number): void;
+    recordBlockExecutionFailed(reason: string): void;
+    recordBlockExecuted(durationMs: number, cost: number): void;
+};
+
 declare const WORKER: url.URL;
 
 type index$6_Config = Config;
@@ -9738,13 +9853,250 @@ declare const index$6_ImporterConfig: typeof ImporterConfig;
 type index$6_ImporterInternal = ImporterInternal;
 declare const index$6_WORKER: typeof WORKER;
 declare const index$6_createImporter: typeof createImporter;
+declare const index$6_createMetrics: typeof createMetrics;
 declare const index$6_main: typeof main;
 declare const index$6_protocol: typeof protocol;
 declare namespace index$6 {
-  export { index$6_ImporterConfig as ImporterConfig, index$6_WORKER as WORKER, index$6_createImporter as createImporter, index$6_main as main, index$6_protocol as protocol };
+  export { index$6_ImporterConfig as ImporterConfig, index$6_WORKER as WORKER, index$6_createImporter as createImporter, index$6_createMetrics as createMetrics, index$6_main as main, index$6_protocol as protocol };
   export type { index$6_Config as Config, index$6_ImporterApi as ImporterApi, index$6_ImporterInternal as ImporterInternal };
 }
 
+declare enum ArgumentType {
+    NO_ARGUMENTS = 0,
+    ONE_IMMEDIATE = 1,
+    TWO_IMMEDIATES = 2,
+    ONE_OFFSET = 3,
+    ONE_REGISTER_ONE_IMMEDIATE = 4,
+    ONE_REGISTER_TWO_IMMEDIATES = 5,
+    ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET = 6,
+    TWO_REGISTERS = 7,
+    TWO_REGISTERS_ONE_IMMEDIATE = 8,
+    TWO_REGISTERS_ONE_OFFSET = 9,
+    TWO_REGISTERS_TWO_IMMEDIATES = 10,
+    THREE_REGISTERS = 11,
+    ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE = 12
+}
+
+declare class ExtendedWitdthImmediateDecoder {
+    private unsignedImmediate;
+    private bytes;
+    constructor();
+    setBytes(bytes: Uint8Array): void;
+    getValue(): bigint;
+    getBytesAsLittleEndian(): Uint8Array<ArrayBufferLike>;
+}
+
+declare class ImmediateDecoder {
+    private u32;
+    private i32;
+    private u64;
+    private i64;
+    private view;
+    private bytes;
+    constructor();
+    setBytes(bytes: Uint8Array): void;
+    /**
+     * @deprecated Use getU32 instead
+     */
+    getUnsigned(): number;
+    /**
+     * @deprecated Use getI32 instead
+     */
+    getSigned(): number;
+    getU32(): number;
+    getI32(): number;
+    getU64(): bigint;
+    getI64(): bigint;
+    getBytesAsLittleEndian(): Uint8Array<ArrayBufferLike>;
+    getExtendedBytesAsLittleEndian(): Uint8Array<ArrayBufferLike>;
+}
+
+type EmptyArgs = {
+    type: ArgumentType.NO_ARGUMENTS;
+    noOfBytesToSkip: number;
+};
+type OneImmediateArgs = {
+    type: ArgumentType.ONE_IMMEDIATE;
+    noOfBytesToSkip: number;
+    /** V_X */
+    immediateDecoder: ImmediateDecoder;
+};
+type ThreeRegistersArgs = {
+    type: ArgumentType.THREE_REGISTERS;
+    noOfBytesToSkip: number;
+    /** W_A */
+    firstRegisterIndex: number;
+    /** W_B */
+    secondRegisterIndex: number;
+    /** W_D */
+    thirdRegisterIndex: number;
+};
+type TwoRegistersArgs = {
+    type: ArgumentType.TWO_REGISTERS;
+    noOfBytesToSkip: number;
+    /** W_A */
+    firstRegisterIndex: number;
+    /** W_D */
+    secondRegisterIndex: number;
+};
+type TwoRegistersOneImmediateArgs = {
+    type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    noOfBytesToSkip: number;
+    /** W_A */
+    firstRegisterIndex: number;
+    /** W_B */
+    secondRegisterIndex: number;
+    /** V_X */
+    immediateDecoder: ImmediateDecoder;
+};
+type OneRegisterOneImmediateArgs = {
+    type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    noOfBytesToSkip: number;
+    /** W_A */
+    registerIndex: number;
+    /** V_X */
+    immediateDecoder: ImmediateDecoder;
+};
+type OneRegisterOneExtendedWidthImmediateArgs = {
+    type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
+    noOfBytesToSkip: number;
+    /** W_A */
+    registerIndex: number;
+    /** V_X */
+    immediateDecoder: ExtendedWitdthImmediateDecoder;
+};
+type TwoRegistersTwoImmediatesArgs = {
+    type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
+    noOfBytesToSkip: number;
+    /** W_A */
+    firstRegisterIndex: number;
+    /** W_B */
+    secondRegisterIndex: number;
+    /** V_X */
+    firstImmediateDecoder: ImmediateDecoder;
+    /** V_Y */
+    secondImmediateDecoder: ImmediateDecoder;
+};
+type TwoImmediatesArgs = {
+    type: ArgumentType.TWO_IMMEDIATES;
+    noOfBytesToSkip: number;
+    /** V_X */
+    firstImmediateDecoder: ImmediateDecoder;
+    /** V_Y */
+    secondImmediateDecoder: ImmediateDecoder;
+};
+type TwoRegistersOneOffsetArgs = {
+    type: ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    noOfBytesToSkip: number;
+    /** W_A */
+    firstRegisterIndex: number;
+    /** W_B */
+    secondRegisterIndex: number;
+    nextPc: number;
+};
+type OneRegisterOneImmediateOneOffsetArgs = {
+    type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    noOfBytesToSkip: number;
+    /** W_A */
+    registerIndex: number;
+    /** V_X */
+    immediateDecoder: ImmediateDecoder;
+    /** V_Y */
+    nextPc: number;
+};
+type OneRegisterTwoImmediatesArgs = {
+    type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    noOfBytesToSkip: number;
+    /** W_A */
+    registerIndex: number;
+    /** V_X */
+    firstImmediateDecoder: ImmediateDecoder;
+    /** V_Y */
+    secondImmediateDecoder: ImmediateDecoder;
+};
+type OneOffsetArgs = {
+    type: ArgumentType.ONE_OFFSET;
+    noOfBytesToSkip: number;
+    /** V_X */
+    nextPc: number;
+};
+type Args = EmptyArgs | OneImmediateArgs | TwoRegistersArgs | ThreeRegistersArgs | TwoRegistersOneImmediateArgs | TwoRegistersTwoImmediatesArgs | OneRegisterOneImmediateOneOffsetArgs | TwoRegistersOneOffsetArgs | OneRegisterOneImmediateArgs | OneOffsetArgs | TwoImmediatesArgs | OneRegisterTwoImmediatesArgs | OneRegisterOneExtendedWidthImmediateArgs;
+declare class ArgsDecoder {
+    private nibblesDecoder;
+    private offsetDecoder;
+    private code;
+    private mask;
+    reset(code: Uint8Array, mask: Mask): void;
+    fillArgs<T extends Args>(pc: number, result: T): void;
+}
+
+type Results = [
+    EmptyArgs,
+    OneImmediateArgs,
+    TwoImmediatesArgs,
+    OneOffsetArgs,
+    OneRegisterOneImmediateArgs,
+    OneRegisterTwoImmediatesArgs,
+    OneRegisterOneImmediateOneOffsetArgs,
+    TwoRegistersArgs,
+    TwoRegistersOneImmediateArgs,
+    TwoRegistersOneOffsetArgs,
+    TwoRegistersTwoImmediatesArgs,
+    ThreeRegistersArgs,
+    OneRegisterOneExtendedWidthImmediateArgs
+];
+declare const createResults: () => Results;
+
+declare class NibblesDecoder {
+    private byte;
+    setByte(byte: number): void;
+    getHighNibble(): number;
+    getLowNibble(): number;
+    getHighNibbleAsRegisterIndex(): number;
+    getLowNibbleAsRegisterIndex(): number;
+    getHighNibbleAsLength(): number;
+    getLowNibbleAsLength(): number;
+}
+
+declare const instructionArgumentTypeMap: ArgumentType[];
+
+type index$5_Args = Args;
+type index$5_ArgsDecoder = ArgsDecoder;
+declare const index$5_ArgsDecoder: typeof ArgsDecoder;
+type index$5_ArgumentType = ArgumentType;
+declare const index$5_ArgumentType: typeof ArgumentType;
+type index$5_EmptyArgs = EmptyArgs;
+type index$5_ExtendedWitdthImmediateDecoder = ExtendedWitdthImmediateDecoder;
+declare const index$5_ExtendedWitdthImmediateDecoder: typeof ExtendedWitdthImmediateDecoder;
+type index$5_ImmediateDecoder = ImmediateDecoder;
+declare const index$5_ImmediateDecoder: typeof ImmediateDecoder;
+type index$5_NibblesDecoder = NibblesDecoder;
+declare const index$5_NibblesDecoder: typeof NibblesDecoder;
+type index$5_OneImmediateArgs = OneImmediateArgs;
+type index$5_OneOffsetArgs = OneOffsetArgs;
+type index$5_OneRegisterOneExtendedWidthImmediateArgs = OneRegisterOneExtendedWidthImmediateArgs;
+type index$5_OneRegisterOneImmediateArgs = OneRegisterOneImmediateArgs;
+type index$5_OneRegisterOneImmediateOneOffsetArgs = OneRegisterOneImmediateOneOffsetArgs;
+type index$5_OneRegisterTwoImmediatesArgs = OneRegisterTwoImmediatesArgs;
+type index$5_ThreeRegistersArgs = ThreeRegistersArgs;
+type index$5_TwoImmediatesArgs = TwoImmediatesArgs;
+type index$5_TwoRegistersArgs = TwoRegistersArgs;
+type index$5_TwoRegistersOneImmediateArgs = TwoRegistersOneImmediateArgs;
+type index$5_TwoRegistersOneOffsetArgs = TwoRegistersOneOffsetArgs;
+type index$5_TwoRegistersTwoImmediatesArgs = TwoRegistersTwoImmediatesArgs;
+declare const index$5_createResults: typeof createResults;
+declare const index$5_instructionArgumentTypeMap: typeof instructionArgumentTypeMap;
+declare namespace index$5 {
+  export { index$5_ArgsDecoder as ArgsDecoder, index$5_ArgumentType as ArgumentType, index$5_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$5_ImmediateDecoder as ImmediateDecoder, index$5_NibblesDecoder as NibblesDecoder, index$5_createResults as createResults, index$5_instructionArgumentTypeMap as instructionArgumentTypeMap };
+  export type { index$5_Args as Args, index$5_EmptyArgs as EmptyArgs, index$5_OneImmediateArgs as OneImmediateArgs, index$5_OneOffsetArgs as OneOffsetArgs, index$5_OneRegisterOneExtendedWidthImmediateArgs as OneRegisterOneExtendedWidthImmediateArgs, index$5_OneRegisterOneImmediateArgs as OneRegisterOneImmediateArgs, index$5_OneRegisterOneImmediateOneOffsetArgs as OneRegisterOneImmediateOneOffsetArgs, index$5_OneRegisterTwoImmediatesArgs as OneRegisterTwoImmediatesArgs, index$5_ThreeRegistersArgs as ThreeRegistersArgs, index$5_TwoImmediatesArgs as TwoImmediatesArgs, index$5_TwoRegistersArgs as TwoRegistersArgs, index$5_TwoRegistersOneImmediateArgs as TwoRegistersOneImmediateArgs, index$5_TwoRegistersOneOffsetArgs as TwoRegistersOneOffsetArgs, index$5_TwoRegistersTwoImmediatesArgs as TwoRegistersTwoImmediatesArgs };
+}
+
+declare class BasicBlocks {
+    private basicBlocks;
+    reset(code: Uint8Array, mask: Mask): void;
+    isBeginningOfBasicBlock(index: number): boolean;
+}
+
 declare class PageFault implements PageFault$1 {
     address: U32;
     isAccessFault: boolean;
@@ -9856,6 +10208,7 @@ declare class MemoryBuilder {
 declare class DebuggerAdapter {
     private readonly pvm;
     constructor(useSbrkGas?: boolean);
+    resetJAM(jamProgram: Uint8Array, pc: number, gas: bigint, args: Uint8Array, hasMetadata?: boolean): void;
     resetGeneric(rawProgram: Uint8Array, flatRegisters: Uint8Array, initialGas: bigint): void;
     reset(rawProgram: Uint8Array, pc: number, gas: bigint, maybeRegisters?: Registers, maybeMemory?: Memory): void;
     getPageDump(pageNumber: number): null | Uint8Array;
@@ -9864,7 +10217,7 @@ declare class DebuggerAdapter {
     getStatus(): Status;
     nextStep(): boolean;
     nSteps(steps: number): boolean;
-    getRegisters(): BigUint64Array;
+    getRegisters(): Uint8Array;
     setRegisters(registers: Uint8Array): void;
     getProgramCounter(): number;
     setNextProgramCounter(nextPc: number): void;
@@ -9906,7 +10259,7 @@ declare class Interpreter implements IPvmInterpreter {
     private basicBlocks;
     private jumpTable;
     constructor({ useSbrkGas }?: InterpreterOptions);
-    resetJam(program: Uint8Array, args: Uint8Array, pc: number, gas: Gas): void;
+    resetJam(program: Uint8Array, args: Uint8Array, pc: number, gas: Gas, hasMetadata?: boolean): void;
     resetGeneric(rawProgram: Uint8Array, pc: number, gas: Gas, maybeRegisters?: Registers, maybeMemory?: Memory): void;
     printProgram(): (string | number)[][];
     runProgram(): void;
@@ -9919,26 +10272,6 @@ declare class Interpreter implements IPvmInterpreter {
     calculateBlockGasCost(): Map<string, number>;
 }
 
-type index$5_DebuggerAdapter = DebuggerAdapter;
-declare const index$5_DebuggerAdapter: typeof DebuggerAdapter;
-type index$5_Interpreter = Interpreter;
-declare const index$5_Interpreter: typeof Interpreter;
-type index$5_Memory = Memory;
-declare const index$5_Memory: typeof Memory;
-type index$5_MemoryBuilder = MemoryBuilder;
-declare const index$5_MemoryBuilder: typeof MemoryBuilder;
-type index$5_MemoryIndex = MemoryIndex;
-type index$5_Registers = Registers;
-declare const index$5_Registers: typeof Registers;
-type index$5_SbrkIndex = SbrkIndex;
-declare const index$5_gasCounter: typeof gasCounter;
-declare const index$5_tryAsMemoryIndex: typeof tryAsMemoryIndex;
-declare const index$5_tryAsSbrkIndex: typeof tryAsSbrkIndex;
-declare namespace index$5 {
-  export { index$5_DebuggerAdapter as DebuggerAdapter, index$5_Interpreter as Interpreter, index$5_Memory as Memory, index$5_MemoryBuilder as MemoryBuilder, index$5_Registers as Registers, index$5_gasCounter as gasCounter, index$5_tryAsMemoryIndex as tryAsMemoryIndex, index$5_tryAsSbrkIndex as tryAsSbrkIndex };
-  export type { index$5_MemoryIndex as MemoryIndex, index$5_SbrkIndex as SbrkIndex };
-}
-
 declare class Program {
     readonly code: Uint8Array;
     readonly registers: Registers;
@@ -9958,16 +10291,6 @@ declare function extractCodeAndMetadata(blobWithMetadata: Uint8Array): {
     code: Uint8Array<ArrayBufferLike>;
 };
 
-type index$4_Program = Program;
-declare const index$4_Program: typeof Program;
-declare const index$4_extractCodeAndMetadata: typeof extractCodeAndMetadata;
-declare namespace index$4 {
-  export {
-    index$4_Program as Program,
-    index$4_extractCodeAndMetadata as extractCodeAndMetadata,
-  };
-}
-
 declare class MemorySegment extends WithDebug {
     readonly start: number;
     readonly end: number;
@@ -10002,22 +10325,84 @@ declare class SpiProgram extends WithDebug {
  */
 declare function decodeStandardProgram(program: Uint8Array, args: Uint8Array): SpiProgram;
 
-type index$3_MemorySegment = MemorySegment;
-declare const index$3_MemorySegment: typeof MemorySegment;
-type index$3_SpiMemory = SpiMemory;
-declare const index$3_SpiMemory: typeof SpiMemory;
-type index$3_SpiProgram = SpiProgram;
-declare const index$3_SpiProgram: typeof SpiProgram;
-declare const index$3_decodeStandardProgram: typeof decodeStandardProgram;
-declare namespace index$3 {
+declare const PAGE_SIZE: number;
+declare const SEGMENT_SIZE: number;
+declare const DATA_LEGNTH: number;
+declare const STACK_SEGMENT = 4278059008;
+declare const ARGS_SEGMENT = 4278124544;
+declare const LAST_PAGE = 4294901760;
+
+declare function alignToSegmentSize(size: number): number;
+declare function alignToPageSize(size: number): number;
+
+declare const index$4_ARGS_SEGMENT: typeof ARGS_SEGMENT;
+declare const index$4_DATA_LEGNTH: typeof DATA_LEGNTH;
+declare const index$4_LAST_PAGE: typeof LAST_PAGE;
+type index$4_MemorySegment = MemorySegment;
+declare const index$4_MemorySegment: typeof MemorySegment;
+declare const index$4_PAGE_SIZE: typeof PAGE_SIZE;
+declare const index$4_SEGMENT_SIZE: typeof SEGMENT_SIZE;
+declare const index$4_STACK_SEGMENT: typeof STACK_SEGMENT;
+type index$4_SpiMemory = SpiMemory;
+declare const index$4_SpiMemory: typeof SpiMemory;
+type index$4_SpiProgram = SpiProgram;
+declare const index$4_SpiProgram: typeof SpiProgram;
+declare const index$4_alignToPageSize: typeof alignToPageSize;
+declare const index$4_alignToSegmentSize: typeof alignToSegmentSize;
+declare const index$4_decodeStandardProgram: typeof decodeStandardProgram;
+declare namespace index$4 {
   export {
-    index$3_MemorySegment as MemorySegment,
-    index$3_SpiMemory as SpiMemory,
-    index$3_SpiProgram as SpiProgram,
-    index$3_decodeStandardProgram as decodeStandardProgram,
+    index$4_ARGS_SEGMENT as ARGS_SEGMENT,
+    index$4_DATA_LEGNTH as DATA_LEGNTH,
+    index$4_LAST_PAGE as LAST_PAGE,
+    index$4_MemorySegment as MemorySegment,
+    index$4_PAGE_SIZE as PAGE_SIZE,
+    index$4_SEGMENT_SIZE as SEGMENT_SIZE,
+    index$4_STACK_SEGMENT as STACK_SEGMENT,
+    index$4_SpiMemory as SpiMemory,
+    index$4_SpiProgram as SpiProgram,
+    index$4_alignToPageSize as alignToPageSize,
+    index$4_alignToSegmentSize as alignToSegmentSize,
+    index$4_decodeStandardProgram as decodeStandardProgram,
   };
 }
 
+type index$3_BasicBlocks = BasicBlocks;
+declare const index$3_BasicBlocks: typeof BasicBlocks;
+type index$3_DebuggerAdapter = DebuggerAdapter;
+declare const index$3_DebuggerAdapter: typeof DebuggerAdapter;
+type index$3_Interpreter = Interpreter;
+declare const index$3_Interpreter: typeof Interpreter;
+type index$3_JumpTable = JumpTable;
+declare const index$3_JumpTable: typeof JumpTable;
+type index$3_Mask = Mask;
+declare const index$3_Mask: typeof Mask;
+type index$3_Memory = Memory;
+declare const index$3_Memory: typeof Memory;
+type index$3_MemoryBuilder = MemoryBuilder;
+declare const index$3_MemoryBuilder: typeof MemoryBuilder;
+type index$3_MemoryIndex = MemoryIndex;
+type index$3_Program = Program;
+declare const index$3_Program: typeof Program;
+type index$3_ProgramDecoder = ProgramDecoder;
+declare const index$3_ProgramDecoder: typeof ProgramDecoder;
+type index$3_ProgramDecoderError = ProgramDecoderError;
+declare const index$3_ProgramDecoderError: typeof ProgramDecoderError;
+type index$3_RegisterIndex = RegisterIndex;
+type index$3_Registers = Registers;
+declare const index$3_Registers: typeof Registers;
+type index$3_SbrkIndex = SbrkIndex;
+declare const index$3_extractCodeAndMetadata: typeof extractCodeAndMetadata;
+declare const index$3_gasCounter: typeof gasCounter;
+declare const index$3_signExtend32To64: typeof signExtend32To64;
+declare const index$3_tryAsMemoryIndex: typeof tryAsMemoryIndex;
+declare const index$3_tryAsRegisterIndex: typeof tryAsRegisterIndex;
+declare const index$3_tryAsSbrkIndex: typeof tryAsSbrkIndex;
+declare namespace index$3 {
+  export { index$3_BasicBlocks as BasicBlocks, index$3_DebuggerAdapter as DebuggerAdapter, index$3_Interpreter as Interpreter, index$3_JumpTable as JumpTable, index$3_Mask as Mask, index$3_Memory as Memory, index$3_MemoryBuilder as MemoryBuilder, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProgramDecoderError as ProgramDecoderError, index$3_Registers as Registers, index$5 as args, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_gasCounter as gasCounter, index$3_signExtend32To64 as signExtend32To64, index$4 as spi, index$3_tryAsMemoryIndex as tryAsMemoryIndex, index$3_tryAsRegisterIndex as tryAsRegisterIndex, index$3_tryAsSbrkIndex as tryAsSbrkIndex };
+  export type { index$3_MemoryIndex as MemoryIndex, index$3_RegisterIndex as RegisterIndex, index$3_SbrkIndex as SbrkIndex };
+}
+
 declare const ENTROPY_BYTES = 32;
 type ENTROPY_BYTES = typeof ENTROPY_BYTES;
 /**
@@ -10248,4 +10633,4 @@ declare namespace index {
   };
 }
 
-export { index$o as block, index$m as block_json, index$u as bytes, index$t as codec, index$r as collections, index$p as config, index$l as config_node, index$q as crypto, index$g as database, index$f as erasure_coding, index$d as fuzz_proto, index$s as hash, index$9 as jam_host_calls, index$n as json_parser, index$b as logger, index$j as mmr, index$x as numbers, index$w as ordering, index$5 as pvm, index$a as pvm_host_calls, index$4 as pvm_program, index$3 as pvm_spi_decoder, index$2 as shuffling, index$i as state, index$1 as state_json, index$h as state_merkleization, index as state_vectors, index$7 as transition, index$k as trie, index$6 as typeberry, index$v as utils, index$c as workers };
+export { index$p as block, index$n as block_json, index$v as bytes, index$u as codec, index$s as collections, index$q as config, index$m as config_node, index$r as crypto, index$h as database, index$g as erasure_coding, index$e as fuzz_proto, index$t as hash, index$9 as jam_host_calls, index$o as json_parser, index$c as logger, index$k as mmr, index$y as numbers, index$x as ordering, index$b as pvm, index$a as pvm_host_calls, index$3 as pvm_interpreter, index$2 as shuffling, index$j as state, index$1 as state_json, index$i as state_merkleization, index as state_vectors, index$7 as transition, index$l as trie, index$6 as typeberry, index$w as utils, index$d as workers };