@typeberry/lib 0.1.2 → 0.1.3-0eba10b

package/index.d.ts

@@ -35,7 +35,9 @@ declare function parseCurrentVersion(env?: string): GpVersion | undefined {
 }
 
 declare function parseCurrentSuite(env?: string): TestSuite | undefined {
-  if (env === undefined) return undefined;
+  if (env === undefined) {
+    return undefined;
+  }
   switch (env) {
     case TestSuite.W3F_DAVXY:
     case TestSuite.JAMDUNA:
@@ -420,6 +422,20 @@ declare const Result$2 = {
   },
 };
 
+// about 2GB, the maximum ArrayBuffer length on Chrome confirmed by several sources:
+// - https://issues.chromium.org/issues/40055619
+// - https://stackoverflow.com/a/72124984
+// - https://onnxruntime.ai/docs/tutorials/web/large-models.html#maximum-size-of-arraybuffer
+declare const MAX_LENGTH$1 = 2145386496;
+
+declare function safeAllocUint8Array(length: number) {
+  if (length > MAX_LENGTH) {
+    // biome-ignore lint/suspicious/noConsole: can't have a dependency on logger here
+    console.warn(`Trying to allocate ${length} bytes, which is greater than the maximum of ${MAX_LENGTH}.`);
+  }
+  return new Uint8Array(Math.min(MAX_LENGTH, length));
+}
+
 /**
  * Utilities for tests.
  */
@@ -573,8 +589,12 @@ declare function deepEqual<T>(
           const aKey = `${a.key}`;
           const bKey = `${b.key}`;
 
-          if (aKey < bKey) return -1;
-          if (bKey < aKey) return 1;
+          if (aKey < bKey) {
+            return -1;
+          }
+          if (bKey < aKey) {
+            return 1;
+          }
           return 0;
         });
     };
@@ -708,59 +728,60 @@ declare function isResult(x: unknown): x is Result$2<unknown, unknown> {
  * as an afterthought.
  */
 
-declare const index$s_ALL_VERSIONS_IN_ORDER: typeof ALL_VERSIONS_IN_ORDER;
-declare const index$s_CURRENT_SUITE: typeof CURRENT_SUITE;
-declare const index$s_CURRENT_VERSION: typeof CURRENT_VERSION;
-type index$s_Compatibility = Compatibility;
-declare const index$s_Compatibility: typeof Compatibility;
-declare const index$s_DEFAULT_SUITE: typeof DEFAULT_SUITE;
-declare const index$s_DEFAULT_VERSION: typeof DEFAULT_VERSION;
-type index$s_DeepEqualOptions = DeepEqualOptions;
-type index$s_EnumMapping = EnumMapping;
-type index$s_ErrorResult<Error> = ErrorResult<Error>;
-type index$s_ErrorsCollector = ErrorsCollector;
-declare const index$s_ErrorsCollector: typeof ErrorsCollector;
-type index$s_GpVersion = GpVersion;
-declare const index$s_GpVersion: typeof GpVersion;
-type index$s_OK = OK;
-type index$s_OkResult<Ok> = OkResult<Ok>;
-type index$s_Opaque<Type, Token extends string> = Opaque<Type, Token>;
-type index$s_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
-declare const index$s_RichTaggedError: typeof RichTaggedError;
-type index$s_StringLiteral<Type> = StringLiteral<Type>;
-declare const index$s_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
-type index$s_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
-type index$s_TestSuite = TestSuite;
-declare const index$s_TestSuite: typeof TestSuite;
-type index$s_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
-type index$s_Uninstantiable = Uninstantiable;
-type index$s_WithDebug = WithDebug;
-declare const index$s_WithDebug: typeof WithDebug;
-type index$s_WithOpaque<Token extends string> = WithOpaque<Token>;
-declare const index$s___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
-declare const index$s_asOpaqueType: typeof asOpaqueType;
-declare const index$s_assertEmpty: typeof assertEmpty;
-declare const index$s_assertNever: typeof assertNever;
-declare const index$s_callCompareFunction: typeof callCompareFunction;
-declare const index$s_check: typeof check;
-declare const index$s_deepEqual: typeof deepEqual;
-declare const index$s_getAllKeysSorted: typeof getAllKeysSorted;
-declare const index$s_inspect: typeof inspect;
-declare const index$s_isBrowser: typeof isBrowser;
-declare const index$s_isResult: typeof isResult;
-declare const index$s_isTaggedError: typeof isTaggedError;
-declare const index$s_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
-declare const index$s_measure: typeof measure;
-declare const index$s_oomWarningPrinted: typeof oomWarningPrinted;
-declare const index$s_parseCurrentSuite: typeof parseCurrentSuite;
-declare const index$s_parseCurrentVersion: typeof parseCurrentVersion;
-declare const index$s_resultToString: typeof resultToString;
-declare const index$s_seeThrough: typeof seeThrough;
-declare const index$s_trimStack: typeof trimStack;
-declare const index$s_workspacePathFix: typeof workspacePathFix;
-declare namespace index$s {
-  export { index$s_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$s_CURRENT_SUITE as CURRENT_SUITE, index$s_CURRENT_VERSION as CURRENT_VERSION, index$s_Compatibility as Compatibility, index$s_DEFAULT_SUITE as DEFAULT_SUITE, index$s_DEFAULT_VERSION as DEFAULT_VERSION, index$s_ErrorsCollector as ErrorsCollector, index$s_GpVersion as GpVersion, Result$2 as Result, index$s_RichTaggedError as RichTaggedError, index$s_TEST_COMPARE_USING as TEST_COMPARE_USING, index$s_TestSuite as TestSuite, index$s_WithDebug as WithDebug, index$s___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$s_asOpaqueType as asOpaqueType, index$s_assertEmpty as assertEmpty, index$s_assertNever as assertNever, index$s_callCompareFunction as callCompareFunction, index$s_check as check, index$s_deepEqual as deepEqual, index$s_getAllKeysSorted as getAllKeysSorted, index$s_inspect as inspect, index$s_isBrowser as isBrowser, index$s_isResult as isResult, index$s_isTaggedError as isTaggedError, index$s_maybeTaggedErrorToString as maybeTaggedErrorToString, index$s_measure as measure, index$s_oomWarningPrinted as oomWarningPrinted, index$s_parseCurrentSuite as parseCurrentSuite, index$s_parseCurrentVersion as parseCurrentVersion, index$s_resultToString as resultToString, index$s_seeThrough as seeThrough, index$s_trimStack as trimStack, index$s_workspacePathFix as workspacePathFix };
-  export type { index$s_DeepEqualOptions as DeepEqualOptions, index$s_EnumMapping as EnumMapping, index$s_ErrorResult as ErrorResult, index$s_OK as OK, index$s_OkResult as OkResult, index$s_Opaque as Opaque, index$s_StringLiteral as StringLiteral, index$s_TaggedError as TaggedError, index$s_TokenOf as TokenOf, index$s_Uninstantiable as Uninstantiable, index$s_WithOpaque as WithOpaque };
+declare const index$u_ALL_VERSIONS_IN_ORDER: typeof ALL_VERSIONS_IN_ORDER;
+declare const index$u_CURRENT_SUITE: typeof CURRENT_SUITE;
+declare const index$u_CURRENT_VERSION: typeof CURRENT_VERSION;
+type index$u_Compatibility = Compatibility;
+declare const index$u_Compatibility: typeof Compatibility;
+declare const index$u_DEFAULT_SUITE: typeof DEFAULT_SUITE;
+declare const index$u_DEFAULT_VERSION: typeof DEFAULT_VERSION;
+type index$u_DeepEqualOptions = DeepEqualOptions;
+type index$u_EnumMapping = EnumMapping;
+type index$u_ErrorResult<Error> = ErrorResult<Error>;
+type index$u_ErrorsCollector = ErrorsCollector;
+declare const index$u_ErrorsCollector: typeof ErrorsCollector;
+type index$u_GpVersion = GpVersion;
+declare const index$u_GpVersion: typeof GpVersion;
+type index$u_OK = OK;
+type index$u_OkResult<Ok> = OkResult<Ok>;
+type index$u_Opaque<Type, Token extends string> = Opaque<Type, Token>;
+type index$u_RichTaggedError<Kind extends string | number, Nested> = RichTaggedError<Kind, Nested>;
+declare const index$u_RichTaggedError: typeof RichTaggedError;
+type index$u_StringLiteral<Type> = StringLiteral<Type>;
+declare const index$u_TEST_COMPARE_USING: typeof TEST_COMPARE_USING;
+type index$u_TaggedError<Kind, Nested> = TaggedError<Kind, Nested>;
+type index$u_TestSuite = TestSuite;
+declare const index$u_TestSuite: typeof TestSuite;
+type index$u_TokenOf<OpaqueType, Type> = TokenOf<OpaqueType, Type>;
+type index$u_Uninstantiable = Uninstantiable;
+type index$u_WithDebug = WithDebug;
+declare const index$u_WithDebug: typeof WithDebug;
+type index$u_WithOpaque<Token extends string> = WithOpaque<Token>;
+declare const index$u___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
+declare const index$u_asOpaqueType: typeof asOpaqueType;
+declare const index$u_assertEmpty: typeof assertEmpty;
+declare const index$u_assertNever: typeof assertNever;
+declare const index$u_callCompareFunction: typeof callCompareFunction;
+declare const index$u_check: typeof check;
+declare const index$u_deepEqual: typeof deepEqual;
+declare const index$u_getAllKeysSorted: typeof getAllKeysSorted;
+declare const index$u_inspect: typeof inspect;
+declare const index$u_isBrowser: typeof isBrowser;
+declare const index$u_isResult: typeof isResult;
+declare const index$u_isTaggedError: typeof isTaggedError;
+declare const index$u_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
+declare const index$u_measure: typeof measure;
+declare const index$u_oomWarningPrinted: typeof oomWarningPrinted;
+declare const index$u_parseCurrentSuite: typeof parseCurrentSuite;
+declare const index$u_parseCurrentVersion: typeof parseCurrentVersion;
+declare const index$u_resultToString: typeof resultToString;
+declare const index$u_safeAllocUint8Array: typeof safeAllocUint8Array;
+declare const index$u_seeThrough: typeof seeThrough;
+declare const index$u_trimStack: typeof trimStack;
+declare const index$u_workspacePathFix: typeof workspacePathFix;
+declare namespace index$u {
+  export { index$u_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$u_CURRENT_SUITE as CURRENT_SUITE, index$u_CURRENT_VERSION as CURRENT_VERSION, index$u_Compatibility as Compatibility, index$u_DEFAULT_SUITE as DEFAULT_SUITE, index$u_DEFAULT_VERSION as DEFAULT_VERSION, index$u_ErrorsCollector as ErrorsCollector, index$u_GpVersion as GpVersion, MAX_LENGTH$1 as MAX_LENGTH, Result$2 as Result, index$u_RichTaggedError as RichTaggedError, index$u_TEST_COMPARE_USING as TEST_COMPARE_USING, index$u_TestSuite as TestSuite, index$u_WithDebug as WithDebug, index$u___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$u_asOpaqueType as asOpaqueType, index$u_assertEmpty as assertEmpty, index$u_assertNever as assertNever, index$u_callCompareFunction as callCompareFunction, index$u_check as check, index$u_deepEqual as deepEqual, index$u_getAllKeysSorted as getAllKeysSorted, index$u_inspect as inspect, index$u_isBrowser as isBrowser, index$u_isResult as isResult, index$u_isTaggedError as isTaggedError, index$u_maybeTaggedErrorToString as maybeTaggedErrorToString, index$u_measure as measure, index$u_oomWarningPrinted as oomWarningPrinted, index$u_parseCurrentSuite as parseCurrentSuite, index$u_parseCurrentVersion as parseCurrentVersion, index$u_resultToString as resultToString, index$u_safeAllocUint8Array as safeAllocUint8Array, index$u_seeThrough as seeThrough, index$u_trimStack as trimStack, index$u_workspacePathFix as workspacePathFix };
+  export type { index$u_DeepEqualOptions as DeepEqualOptions, index$u_EnumMapping as EnumMapping, index$u_ErrorResult as ErrorResult, index$u_OK as OK, index$u_OkResult as OkResult, index$u_Opaque as Opaque, index$u_StringLiteral as StringLiteral, index$u_TaggedError as TaggedError, index$u_TokenOf as TokenOf, index$u_Uninstantiable as Uninstantiable, index$u_WithOpaque as WithOpaque };
 }
 
 /** A return value of some comparator. */
@@ -813,14 +834,14 @@ declare class Ordering {
  */
 type Comparator<V> = (self: V, other: V) => Ordering;
 
-type index$r_Comparator<V> = Comparator<V>;
-type index$r_Ordering = Ordering;
-declare const index$r_Ordering: typeof Ordering;
-type index$r_OrderingValue = OrderingValue;
-declare const index$r_OrderingValue: typeof OrderingValue;
-declare namespace index$r {
-  export { index$r_Ordering as Ordering, index$r_OrderingValue as OrderingValue };
-  export type { index$r_Comparator as Comparator };
+type index$t_Comparator<V> = Comparator<V>;
+type index$t_Ordering = Ordering;
+declare const index$t_Ordering: typeof Ordering;
+type index$t_OrderingValue = OrderingValue;
+declare const index$t_OrderingValue: typeof OrderingValue;
+declare namespace index$t {
+  export { index$t_Ordering as Ordering, index$t_OrderingValue as OrderingValue };
+  export type { index$t_Comparator as Comparator };
 }
 
 // TODO: [MaSo] Update BytesBlob and Bytes, so they return Result (not throw error)
@@ -929,7 +950,7 @@ declare class BytesBlob {
   static blobFromParts(v: Uint8Array | Uint8Array[], ...rest: Uint8Array[]) {
     const vArr = v instanceof Uint8Array ? [v] : v;
     const totalLength = vArr.reduce((a, v) => a + v.length, 0) + rest.reduce((a, v) => a + v.length, 0);
-    const buffer = new Uint8Array(totalLength);
+    const buffer = safeAllocUint8Array(totalLength);
     let offset = 0;
     for (const r of vArr) {
       buffer.set(r, offset);
@@ -1012,7 +1033,7 @@ declare class Bytes<T extends number> extends BytesBlob {
 
   /** Create an empty [`Bytes<X>`] of given length. */
   static zero<X extends number>(len: X): Bytes<X> {
-    return new Bytes(new Uint8Array(len), len);
+    return new Bytes(safeAllocUint8Array(len), len);
   }
 
   // TODO [ToDr] `fill` should have the argments swapped to align with the rest.
@@ -1133,7 +1154,7 @@ declare class BitVec {
    * Create new [`BitVec`] with all values set to `false`.
    */
   static empty(bitLength: number) {
-    const data = new Uint8Array(Math.ceil(bitLength / 8));
+    const data = safeAllocUint8Array(Math.ceil(bitLength / 8));
     return new BitVec(data, bitLength);
   }
 
@@ -1213,41 +1234,41 @@ declare class BitVec {
   }
 }
 
-type index$q_BitVec = BitVec;
-declare const index$q_BitVec: typeof BitVec;
-type index$q_Bytes<T extends number> = Bytes<T>;
-declare const index$q_Bytes: typeof Bytes;
-type index$q_BytesBlob = BytesBlob;
-declare const index$q_BytesBlob: typeof BytesBlob;
-declare const index$q_CODE_OF_0: typeof CODE_OF_0;
-declare const index$q_CODE_OF_9: typeof CODE_OF_9;
-declare const index$q_CODE_OF_A: typeof CODE_OF_A;
-declare const index$q_CODE_OF_F: typeof CODE_OF_F;
-declare const index$q_CODE_OF_a: typeof CODE_OF_a;
-declare const index$q_CODE_OF_f: typeof CODE_OF_f;
-declare const index$q_VALUE_OF_A: typeof VALUE_OF_A;
-declare const index$q_byteFromString: typeof byteFromString;
-declare const index$q_bytesBlobComparator: typeof bytesBlobComparator;
-declare const index$q_bytesToHexString: typeof bytesToHexString;
-declare const index$q_numberFromCharCode: typeof numberFromCharCode;
-declare const index$q_u8ArraySameLengthEqual: typeof u8ArraySameLengthEqual;
-declare namespace index$q {
+type index$s_BitVec = BitVec;
+declare const index$s_BitVec: typeof BitVec;
+type index$s_Bytes<T extends number> = Bytes<T>;
+declare const index$s_Bytes: typeof Bytes;
+type index$s_BytesBlob = BytesBlob;
+declare const index$s_BytesBlob: typeof BytesBlob;
+declare const index$s_CODE_OF_0: typeof CODE_OF_0;
+declare const index$s_CODE_OF_9: typeof CODE_OF_9;
+declare const index$s_CODE_OF_A: typeof CODE_OF_A;
+declare const index$s_CODE_OF_F: typeof CODE_OF_F;
+declare const index$s_CODE_OF_a: typeof CODE_OF_a;
+declare const index$s_CODE_OF_f: typeof CODE_OF_f;
+declare const index$s_VALUE_OF_A: typeof VALUE_OF_A;
+declare const index$s_byteFromString: typeof byteFromString;
+declare const index$s_bytesBlobComparator: typeof bytesBlobComparator;
+declare const index$s_bytesToHexString: typeof bytesToHexString;
+declare const index$s_numberFromCharCode: typeof numberFromCharCode;
+declare const index$s_u8ArraySameLengthEqual: typeof u8ArraySameLengthEqual;
+declare namespace index$s {
   export {
-    index$q_BitVec as BitVec,
-    index$q_Bytes as Bytes,
-    index$q_BytesBlob as BytesBlob,
-    index$q_CODE_OF_0 as CODE_OF_0,
-    index$q_CODE_OF_9 as CODE_OF_9,
-    index$q_CODE_OF_A as CODE_OF_A,
-    index$q_CODE_OF_F as CODE_OF_F,
-    index$q_CODE_OF_a as CODE_OF_a,
-    index$q_CODE_OF_f as CODE_OF_f,
-    index$q_VALUE_OF_A as VALUE_OF_A,
-    index$q_byteFromString as byteFromString,
-    index$q_bytesBlobComparator as bytesBlobComparator,
-    index$q_bytesToHexString as bytesToHexString,
-    index$q_numberFromCharCode as numberFromCharCode,
-    index$q_u8ArraySameLengthEqual as u8ArraySameLengthEqual,
+    index$s_BitVec as BitVec,
+    index$s_Bytes as Bytes,
+    index$s_BytesBlob as BytesBlob,
+    index$s_CODE_OF_0 as CODE_OF_0,
+    index$s_CODE_OF_9 as CODE_OF_9,
+    index$s_CODE_OF_A as CODE_OF_A,
+    index$s_CODE_OF_F as CODE_OF_F,
+    index$s_CODE_OF_a as CODE_OF_a,
+    index$s_CODE_OF_f as CODE_OF_f,
+    index$s_VALUE_OF_A as VALUE_OF_A,
+    index$s_byteFromString as byteFromString,
+    index$s_bytesBlobComparator as bytesBlobComparator,
+    index$s_bytesToHexString as bytesToHexString,
+    index$s_numberFromCharCode as numberFromCharCode,
+    index$s_u8ArraySameLengthEqual as u8ArraySameLengthEqual,
   };
 }
 
@@ -1395,37 +1416,37 @@ declare const minU64 = (a: U64, ...values: U64[]): U64 => values.reduce((min, va
 /** Get the biggest value between U64 a and values given as input parameters. */
 declare const maxU64 = (a: U64, ...values: U64[]): U64 => values.reduce((max, value) => (value < max ? max : value), a);
 
-type index$p_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
-declare const index$p_MAX_VALUE_U16: typeof MAX_VALUE_U16;
-declare const index$p_MAX_VALUE_U32: typeof MAX_VALUE_U32;
-declare const index$p_MAX_VALUE_U64: typeof MAX_VALUE_U64;
-declare const index$p_MAX_VALUE_U8: typeof MAX_VALUE_U8;
-type index$p_U16 = U16;
-type index$p_U32 = U32;
-type index$p_U64 = U64;
-type index$p_U8 = U8;
-type index$p_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
-declare const index$p___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
-declare const index$p_asTypedNumber: typeof asTypedNumber;
-declare const index$p_isU16: typeof isU16;
-declare const index$p_isU32: typeof isU32;
-declare const index$p_isU64: typeof isU64;
-declare const index$p_isU8: typeof isU8;
-declare const index$p_leBytesAsU32: typeof leBytesAsU32;
-declare const index$p_maxU64: typeof maxU64;
-declare const index$p_minU64: typeof minU64;
-declare const index$p_sumU32: typeof sumU32;
-declare const index$p_sumU64: typeof sumU64;
-declare const index$p_tryAsU16: typeof tryAsU16;
-declare const index$p_tryAsU32: typeof tryAsU32;
-declare const index$p_tryAsU64: typeof tryAsU64;
-declare const index$p_tryAsU8: typeof tryAsU8;
-declare const index$p_u32AsLeBytes: typeof u32AsLeBytes;
-declare const index$p_u64FromParts: typeof u64FromParts;
-declare const index$p_u64IntoParts: typeof u64IntoParts;
-declare namespace index$p {
-  export { index$p_MAX_VALUE_U16 as MAX_VALUE_U16, index$p_MAX_VALUE_U32 as MAX_VALUE_U32, index$p_MAX_VALUE_U64 as MAX_VALUE_U64, index$p_MAX_VALUE_U8 as MAX_VALUE_U8, index$p___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$p_asTypedNumber as asTypedNumber, index$p_isU16 as isU16, index$p_isU32 as isU32, index$p_isU64 as isU64, index$p_isU8 as isU8, index$p_leBytesAsU32 as leBytesAsU32, index$p_maxU64 as maxU64, index$p_minU64 as minU64, index$p_sumU32 as sumU32, index$p_sumU64 as sumU64, index$p_tryAsU16 as tryAsU16, index$p_tryAsU32 as tryAsU32, index$p_tryAsU64 as tryAsU64, index$p_tryAsU8 as tryAsU8, index$p_u32AsLeBytes as u32AsLeBytes, index$p_u64FromParts as u64FromParts, index$p_u64IntoParts as u64IntoParts };
-  export type { index$p_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$p_U16 as U16, index$p_U32 as U32, index$p_U64 as U64, index$p_U8 as U8, index$p_WithBytesRepresentation as WithBytesRepresentation };
+type index$r_FixedSizeNumber<Bytes extends number> = FixedSizeNumber<Bytes>;
+declare const index$r_MAX_VALUE_U16: typeof MAX_VALUE_U16;
+declare const index$r_MAX_VALUE_U32: typeof MAX_VALUE_U32;
+declare const index$r_MAX_VALUE_U64: typeof MAX_VALUE_U64;
+declare const index$r_MAX_VALUE_U8: typeof MAX_VALUE_U8;
+type index$r_U16 = U16;
+type index$r_U32 = U32;
+type index$r_U64 = U64;
+type index$r_U8 = U8;
+type index$r_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
+declare const index$r___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
+declare const index$r_asTypedNumber: typeof asTypedNumber;
+declare const index$r_isU16: typeof isU16;
+declare const index$r_isU32: typeof isU32;
+declare const index$r_isU64: typeof isU64;
+declare const index$r_isU8: typeof isU8;
+declare const index$r_leBytesAsU32: typeof leBytesAsU32;
+declare const index$r_maxU64: typeof maxU64;
+declare const index$r_minU64: typeof minU64;
+declare const index$r_sumU32: typeof sumU32;
+declare const index$r_sumU64: typeof sumU64;
+declare const index$r_tryAsU16: typeof tryAsU16;
+declare const index$r_tryAsU32: typeof tryAsU32;
+declare const index$r_tryAsU64: typeof tryAsU64;
+declare const index$r_tryAsU8: typeof tryAsU8;
+declare const index$r_u32AsLeBytes: typeof u32AsLeBytes;
+declare const index$r_u64FromParts: typeof u64FromParts;
+declare const index$r_u64IntoParts: typeof u64IntoParts;
+declare namespace index$r {
+  export { index$r_MAX_VALUE_U16 as MAX_VALUE_U16, index$r_MAX_VALUE_U32 as MAX_VALUE_U32, index$r_MAX_VALUE_U64 as MAX_VALUE_U64, index$r_MAX_VALUE_U8 as MAX_VALUE_U8, index$r___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$r_asTypedNumber as asTypedNumber, index$r_isU16 as isU16, index$r_isU32 as isU32, index$r_isU64 as isU64, index$r_isU8 as isU8, index$r_leBytesAsU32 as leBytesAsU32, index$r_maxU64 as maxU64, index$r_minU64 as minU64, index$r_sumU32 as sumU32, index$r_sumU64 as sumU64, index$r_tryAsU16 as tryAsU16, index$r_tryAsU32 as tryAsU32, index$r_tryAsU64 as tryAsU64, index$r_tryAsU8 as tryAsU8, index$r_u32AsLeBytes as u32AsLeBytes, index$r_u64FromParts as u64FromParts, index$r_u64IntoParts as u64IntoParts };
+  export type { index$r_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$r_U16 as U16, index$r_U32 as U32, index$r_U64 as U64, index$r_U8 as U8, index$r_WithBytesRepresentation as WithBytesRepresentation };
 }
 
 /** A decoder for some specific type `T` */
@@ -2527,6 +2548,7 @@ declare class ViewField<T, V> implements ViewField<T, V> {
   private cachedBlob: BytesBlob | undefined;
 
   constructor(
+    private readonly name: string,
     private readonly getView: () => V,
     private readonly getValue: () => T,
     private readonly getEncoded: () => BytesBlob,
@@ -2555,6 +2577,10 @@ declare class ViewField<T, V> implements ViewField<T, V> {
     }
     return this.cachedBlob;
   }
+
+  toString() {
+    return `ViewField<${this.name}>`;
+  }
 }
 
 /**
@@ -2638,6 +2664,7 @@ declare abstract class ObjectView<T> {
       const field = this.descriptorsKeys[i];
       const type = this.descriptors[field as keyof DescriptorRecord<T>];
       lastItem = new ViewField(
+        `${this.toString()}.${String(field)}`,
         () => type.View.decode(fieldDecoder.clone()),
         () => type.decode(fieldDecoder.clone()),
         () => type.skipEncoded(fieldDecoder.clone()),
@@ -2655,6 +2682,10 @@ declare abstract class ObjectView<T> {
 
     return lastItem as ViewField<T[K], unknown>;
   }
+
+  toString() {
+    return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
+  }
 }
 
 /**
@@ -2755,6 +2786,7 @@ declare class SequenceView<T, V = T> {
       const fieldDecoder = skipper.decoder.clone();
       const type = this.descriptor;
       lastItem = new ViewField(
+        `${this.toString()}[${index}]`,
         () => type.View.decode(fieldDecoder.clone()),
         () => type.decode(fieldDecoder.clone()),
         () => type.skipEncoded(fieldDecoder.clone()),
@@ -2771,6 +2803,10 @@ declare class SequenceView<T, V = T> {
     }
     return lastItem;
   }
+
+  toString() {
+    return `SequenceView<${this.descriptor.name}>(cache: ${this.cache.size})`;
+  }
 }
 
 /**
@@ -3400,52 +3436,145 @@ declare function sequenceViewFixLen<T, V>(
   );
 }
 
-type index$o_ClassConstructor<T> = ClassConstructor<T>;
-type index$o_Codec<T> = Codec<T>;
-type index$o_CodecRecord<T> = CodecRecord<T>;
-declare const index$o_DEFAULT_START_LENGTH: typeof DEFAULT_START_LENGTH;
-type index$o_Decode<T> = Decode<T>;
-type index$o_Decoder = Decoder;
-declare const index$o_Decoder: typeof Decoder;
-type index$o_DescribedBy<T> = DescribedBy<T>;
-type index$o_Descriptor<T, V = T> = Descriptor<T, V>;
-declare const index$o_Descriptor: typeof Descriptor;
-type index$o_DescriptorRecord<T> = DescriptorRecord<T>;
-type index$o_Encode<T> = Encode<T>;
-type index$o_Encoder = Encoder;
-declare const index$o_Encoder: typeof Encoder;
-type index$o_LengthRange = LengthRange;
-declare const index$o_MASKS: typeof MASKS;
-declare const index$o_MAX_LENGTH: typeof MAX_LENGTH;
-type index$o_ObjectView<T> = ObjectView<T>;
-declare const index$o_ObjectView: typeof ObjectView;
-type index$o_OptionalRecord<T> = OptionalRecord<T>;
-type index$o_PropertyKeys<T> = PropertyKeys<T>;
-type index$o_SequenceView<T, V = T> = SequenceView<T, V>;
-declare const index$o_SequenceView: typeof SequenceView;
-type index$o_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
-type index$o_SizeHint = SizeHint;
-declare const index$o_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
-declare const index$o_TYPICAL_SEQUENCE_LENGTH: typeof TYPICAL_SEQUENCE_LENGTH;
-type index$o_ViewField<T, V> = ViewField<T, V>;
-declare const index$o_ViewField: typeof ViewField;
-type index$o_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
-declare const index$o_addSizeHints: typeof addSizeHints;
-declare const index$o_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
-declare const index$o_exactHint: typeof exactHint;
-declare const index$o_forEachDescriptor: typeof forEachDescriptor;
-declare const index$o_hasUniqueView: typeof hasUniqueView;
-declare const index$o_objectView: typeof objectView;
-declare const index$o_readonlyArray: typeof readonlyArray;
-declare const index$o_sequenceViewFixLen: typeof sequenceViewFixLen;
-declare const index$o_sequenceViewVarLen: typeof sequenceViewVarLen;
-declare const index$o_tryAsExactBytes: typeof tryAsExactBytes;
-declare const index$o_validateLength: typeof validateLength;
-declare namespace index$o {
-  export { index$o_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$o_Decoder as Decoder, index$o_Descriptor as Descriptor, index$o_Encoder as Encoder, index$o_MASKS as MASKS, index$o_MAX_LENGTH as MAX_LENGTH, index$o_ObjectView as ObjectView, index$o_SequenceView as SequenceView, index$o_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$o_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$o_ViewField as ViewField, index$o_addSizeHints as addSizeHints, codec$1 as codec, index$o_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$o_exactHint as exactHint, index$o_forEachDescriptor as forEachDescriptor, index$o_hasUniqueView as hasUniqueView, index$o_objectView as objectView, index$o_readonlyArray as readonlyArray, index$o_sequenceViewFixLen as sequenceViewFixLen, index$o_sequenceViewVarLen as sequenceViewVarLen, index$o_tryAsExactBytes as tryAsExactBytes, index$o_validateLength as validateLength };
-  export type { index$o_ClassConstructor as ClassConstructor, index$o_Codec as Codec, index$o_CodecRecord as CodecRecord, index$o_Decode as Decode, index$o_DescribedBy as DescribedBy, index$o_DescriptorRecord as DescriptorRecord, index$o_Encode as Encode, index$o_LengthRange as LengthRange, index$o_OptionalRecord as OptionalRecord, Options$1 as Options, index$o_PropertyKeys as PropertyKeys, index$o_SimpleDescriptorRecord as SimpleDescriptorRecord, index$o_SizeHint as SizeHint, index$o_ViewOf as ViewOf };
+type index$q_ClassConstructor<T> = ClassConstructor<T>;
+type index$q_Codec<T> = Codec<T>;
+type index$q_CodecRecord<T> = CodecRecord<T>;
+declare const index$q_DEFAULT_START_LENGTH: typeof DEFAULT_START_LENGTH;
+type index$q_Decode<T> = Decode<T>;
+type index$q_Decoder = Decoder;
+declare const index$q_Decoder: typeof Decoder;
+type index$q_DescribedBy<T> = DescribedBy<T>;
+type index$q_Descriptor<T, V = T> = Descriptor<T, V>;
+declare const index$q_Descriptor: typeof Descriptor;
+type index$q_DescriptorRecord<T> = DescriptorRecord<T>;
+type index$q_Encode<T> = Encode<T>;
+type index$q_Encoder = Encoder;
+declare const index$q_Encoder: typeof Encoder;
+type index$q_LengthRange = LengthRange;
+declare const index$q_MASKS: typeof MASKS;
+declare const index$q_MAX_LENGTH: typeof MAX_LENGTH;
+type index$q_ObjectView<T> = ObjectView<T>;
+declare const index$q_ObjectView: typeof ObjectView;
+type index$q_OptionalRecord<T> = OptionalRecord<T>;
+type index$q_PropertyKeys<T> = PropertyKeys<T>;
+type index$q_SequenceView<T, V = T> = SequenceView<T, V>;
+declare const index$q_SequenceView: typeof SequenceView;
+type index$q_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
+type index$q_SizeHint = SizeHint;
+declare const index$q_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
+declare const index$q_TYPICAL_SEQUENCE_LENGTH: typeof TYPICAL_SEQUENCE_LENGTH;
+type index$q_ViewField<T, V> = ViewField<T, V>;
+declare const index$q_ViewField: typeof ViewField;
+type index$q_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
+declare const index$q_addSizeHints: typeof addSizeHints;
+declare const index$q_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
+declare const index$q_exactHint: typeof exactHint;
+declare const index$q_forEachDescriptor: typeof forEachDescriptor;
+declare const index$q_hasUniqueView: typeof hasUniqueView;
+declare const index$q_objectView: typeof objectView;
+declare const index$q_readonlyArray: typeof readonlyArray;
+declare const index$q_sequenceViewFixLen: typeof sequenceViewFixLen;
+declare const index$q_sequenceViewVarLen: typeof sequenceViewVarLen;
+declare const index$q_tryAsExactBytes: typeof tryAsExactBytes;
+declare const index$q_validateLength: typeof validateLength;
+declare namespace index$q {
+  export { index$q_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$q_Decoder as Decoder, index$q_Descriptor as Descriptor, index$q_Encoder as Encoder, index$q_MASKS as MASKS, index$q_MAX_LENGTH as MAX_LENGTH, index$q_ObjectView as ObjectView, index$q_SequenceView as SequenceView, index$q_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$q_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$q_ViewField as ViewField, index$q_addSizeHints as addSizeHints, codec$1 as codec, index$q_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$q_exactHint as exactHint, index$q_forEachDescriptor as forEachDescriptor, index$q_hasUniqueView as hasUniqueView, index$q_objectView as objectView, index$q_readonlyArray as readonlyArray, index$q_sequenceViewFixLen as sequenceViewFixLen, index$q_sequenceViewVarLen as sequenceViewVarLen, index$q_tryAsExactBytes as tryAsExactBytes, index$q_validateLength as validateLength };
+  export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
+}
+
+/**
+ * A utility class providing a readonly view over a portion of an array without copying it.
+ */
+declare class ArrayView<T> implements Iterable<T> {
+  private readonly source: T[];
+  public readonly length: number;
+
+  private constructor(
+    source: T[],
+    private readonly start: number,
+    private readonly end: number,
+  ) {
+    this.source = source;
+    this.length = end - start;
+  }
+
+  static from<T>(source: T[], start = 0, end = source.length): ArrayView<T> {
+    check`
+      ${start >= 0 && end <= source.length && start <= end} 
+      Invalid start (${start})/end (${end}) for ArrayView 
+    `;
+    return new ArrayView(source, start, end);
+  }
+
+  get(i: number): T {
+    check`
+      ${i >= 0 && i < this.length}
+      Index out of bounds: ${i} < ${this.length}
+    `;
+    return this.source[this.start + i];
+  }
+
+  subview(from: number, to: number = this.length): ArrayView<T> {
+    return ArrayView.from(this.source, this.start + from, this.start + to);
+  }
+
+  toArray(): T[] {
+    return this.source.slice(this.start, this.end);
+  }
+
+  *[Symbol.iterator](): Iterator<T> {
+    for (let i = this.start; i < this.end; i++) {
+      yield this.source[i];
+    }
+  }
 }
 
+type ITypedArray = Uint8Array | Uint16Array | Uint32Array;
+type IDataType = string | Buffer | ITypedArray;
+
+type IHasher = {
+    /**
+     * Initializes hash state to default value
+     */
+    init: () => IHasher;
+    /**
+     * Updates the hash content with the given data
+     */
+    update: (data: IDataType) => IHasher;
+    /**
+     * Calculates the hash of all of the data passed to be hashed with hash.update().
+     * Defaults to hexadecimal string
+     * @param outputType If outputType is "binary", it returns Uint8Array. Otherwise it
+     *                   returns hexadecimal string
+     */
+    digest: {
+        (outputType: "binary"): Uint8Array;
+        (outputType?: "hex"): string;
+    };
+    /**
+     * Save the current internal state of the hasher for later resumption with load().
+     * Cannot be called before .init() or after .digest()
+     *
+     * Note that this state can include arbitrary information about the value being hashed (e.g.
+     * could include N plaintext bytes from the value), so needs to be treated as being as
+     * sensitive as the input value itself.
+     */
+    save: () => Uint8Array;
+    /**
+     * Resume a state that was created by save(). If this state was not created by a
+     * compatible build of hash-wasm, an exception will be thrown.
+     */
+    load: (state: Uint8Array) => IHasher;
+    /**
+     * Block size in bytes
+     */
+    blockSize: number;
+    /**
+     * Digest size in bytes
+     */
+    digestSize: number;
+};
+
 /**
  * Size of the output of the hash functions.
  *
@@ -3501,144 +3630,46 @@ declare class WithHashAndBytes<THash extends OpaqueHash, TData> extends WithHash
   }
 }
 
-/** Allocator interface - returns an empty bytes vector that can be filled with the hash. */
-interface HashAllocator {
-  /** Return a new hash destination. */
-  emptyHash(): OpaqueHash;
-}
-
-/** The simplest allocator returning just a fresh copy of bytes each time. */
-declare class SimpleAllocator implements HashAllocator {
-  emptyHash(): OpaqueHash {
-    return Bytes.zero(HASH_SIZE);
-  }
-}
+declare const zero$1 = Bytes.zero(HASH_SIZE);
 
-/** An allocator that works by allocating larger (continuous) pages of memory. */
-declare class PageAllocator implements HashAllocator {
-  private page: Uint8Array = new Uint8Array(0);
-  private currentHash = 0;
-
-  // TODO [ToDr] Benchmark the performance!
-  constructor(private readonly hashesPerPage: number) {
-    check`${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
-    this.resetPage();
-  }
-
-  private resetPage() {
-    const pageSizeBytes = this.hashesPerPage * HASH_SIZE;
-    this.currentHash = 0;
-    this.page = new Uint8Array(pageSizeBytes);
+declare class Blake2b {
+  static async createHasher() {
+    return new Blake2b(await createBLAKE2b(HASH_SIZE * 8));
   }
 
-  emptyHash(): OpaqueHash {
-    const startIdx = this.currentHash * HASH_SIZE;
-    const endIdx = startIdx + HASH_SIZE;
+  private constructor(private readonly hasher: IHasher) {}
 
-    this.currentHash += 1;
-    if (this.currentHash >= this.hashesPerPage) {
-      this.resetPage();
+  /**
+   * Hash given collection of blobs.
+   *
+   * If empty array is given a zero-hash is returned.
+   */
+  hashBlobs<H extends Blake2bHash>(r: (BytesBlob | Uint8Array)[]): H {
+    if (r.length === 0) {
+      return zero.asOpaque();
     }
 
-    return Bytes.fromBlob(this.page.subarray(startIdx, endIdx), HASH_SIZE);
+    const hasher = this.hasher.init();
+    for (const v of r) {
+      hasher.update(v instanceof BytesBlob ? v.raw : v);
+    }
+    return Bytes.fromBlob(hasher.digest("binary"), HASH_SIZE).asOpaque();
   }
-}
 
-declare const defaultAllocator = new SimpleAllocator();
-
-/**
- * Hash given collection of blobs.
- *
- * If empty array is given a zero-hash is returned.
- */
-declare function hashBlobs$1<H extends Blake2bHash>(
-  r: (BytesBlob | Uint8Array)[],
-  allocator: HashAllocator = defaultAllocator,
-): H {
-  const out = allocator.emptyHash();
-  if (r.length === 0) {
-    return out.asOpaque();
+  /** Hash given blob of bytes. */
+  hashBytes(blob: BytesBlob | Uint8Array): Blake2bHash {
+    const hasher = this.hasher.init();
+    const bytes = blob instanceof BytesBlob ? blob.raw : blob;
+    hasher.update(bytes);
+    return Bytes.fromBlob(hasher.digest("binary"), HASH_SIZE).asOpaque();
   }
 
-  const hasher = blake2b(HASH_SIZE);
-  for (const v of r) {
-    hasher?.update(v instanceof BytesBlob ? v.raw : v);
+  /** Convert given string into bytes and hash it. */
+  hashString(str: string) {
+    return this.hashBytes(BytesBlob.blobFromString(str));
   }
-  hasher?.digest(out.raw);
-  return out.asOpaque();
 }
 
-/** Hash given blob of bytes. */
-declare function hashBytes(blob: BytesBlob | Uint8Array, allocator: HashAllocator = defaultAllocator): Blake2bHash {
-  const hasher = blake2b(HASH_SIZE);
-  const bytes = blob instanceof BytesBlob ? blob.raw : blob;
-  hasher?.update(bytes);
-  const out = allocator.emptyHash();
-  hasher?.digest(out.raw);
-  return out;
-}
-
-/** Convert given string into bytes and hash it. */
-declare function hashString(str: string, allocator: HashAllocator = defaultAllocator) {
-  return hashBytes(BytesBlob.blobFromString(str), allocator);
-}
-
-declare const blake2b_hashBytes: typeof hashBytes;
-declare const blake2b_hashString: typeof hashString;
-declare namespace blake2b {
-  export {
-    hashBlobs$1 as hashBlobs,
-    blake2b_hashBytes as hashBytes,
-    blake2b_hashString as hashString,
-  };
-}
-
-type ITypedArray = Uint8Array | Uint16Array | Uint32Array;
-type IDataType = string | Buffer | ITypedArray;
-
-type IHasher = {
-    /**
-     * Initializes hash state to default value
-     */
-    init: () => IHasher;
-    /**
-     * Updates the hash content with the given data
-     */
-    update: (data: IDataType) => IHasher;
-    /**
-     * Calculates the hash of all of the data passed to be hashed with hash.update().
-     * Defaults to hexadecimal string
-     * @param outputType If outputType is "binary", it returns Uint8Array. Otherwise it
-     *                   returns hexadecimal string
-     */
-    digest: {
-        (outputType: "binary"): Uint8Array;
-        (outputType?: "hex"): string;
-    };
-    /**
-     * Save the current internal state of the hasher for later resumption with load().
-     * Cannot be called before .init() or after .digest()
-     *
-     * Note that this state can include arbitrary information about the value being hashed (e.g.
-     * could include N plaintext bytes from the value), so needs to be treated as being as
-     * sensitive as the input value itself.
-     */
-    save: () => Uint8Array;
-    /**
-     * Resume a state that was created by save(). If this state was not created by a
-     * compatible build of hash-wasm, an exception will be thrown.
-     */
-    load: (state: Uint8Array) => IHasher;
-    /**
-     * Block size in bytes
-     */
-    blockSize: number;
-    /**
-     * Digest size in bytes
-     */
-    digestSize: number;
-};
-
 declare class KeccakHasher {
   static async create(): Promise<KeccakHasher> {
     return new KeccakHasher(await createKeccak(256));
@@ -3666,28 +3697,26 @@ declare namespace keccak {
   };
 }
 
-type index$n_Blake2bHash = Blake2bHash;
-type index$n_HASH_SIZE = HASH_SIZE;
-type index$n_HashAllocator = HashAllocator;
-type index$n_KeccakHash = KeccakHash;
-type index$n_OpaqueHash = OpaqueHash;
-type index$n_PageAllocator = PageAllocator;
-declare const index$n_PageAllocator: typeof PageAllocator;
-type index$n_SimpleAllocator = SimpleAllocator;
-declare const index$n_SimpleAllocator: typeof SimpleAllocator;
-type index$n_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
-type index$n_TruncatedHash = TruncatedHash;
-type index$n_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
-declare const index$n_WithHash: typeof WithHash;
-type index$n_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
-declare const index$n_WithHashAndBytes: typeof WithHashAndBytes;
-declare const index$n_ZERO_HASH: typeof ZERO_HASH;
-declare const index$n_blake2b: typeof blake2b;
-declare const index$n_defaultAllocator: typeof defaultAllocator;
-declare const index$n_keccak: typeof keccak;
-declare namespace index$n {
-  export { index$n_PageAllocator as PageAllocator, index$n_SimpleAllocator as SimpleAllocator, index$n_WithHash as WithHash, index$n_WithHashAndBytes as WithHashAndBytes, index$n_ZERO_HASH as ZERO_HASH, index$n_blake2b as blake2b, index$n_defaultAllocator as defaultAllocator, index$n_keccak as keccak };
-  export type { index$n_Blake2bHash as Blake2bHash, index$n_HASH_SIZE as HASH_SIZE, index$n_HashAllocator as HashAllocator, index$n_KeccakHash as KeccakHash, index$n_OpaqueHash as OpaqueHash, index$n_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$n_TruncatedHash as TruncatedHash };
+// TODO [ToDr] (#213) this should most likely be moved to a separate
+// package to avoid pulling in unnecessary deps.
+
+type index$p_Blake2b = Blake2b;
+declare const index$p_Blake2b: typeof Blake2b;
+type index$p_Blake2bHash = Blake2bHash;
+type index$p_HASH_SIZE = HASH_SIZE;
+type index$p_KeccakHash = KeccakHash;
+type index$p_OpaqueHash = OpaqueHash;
+type index$p_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
+type index$p_TruncatedHash = TruncatedHash;
+type index$p_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
+declare const index$p_WithHash: typeof WithHash;
+type index$p_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
+declare const index$p_WithHashAndBytes: typeof WithHashAndBytes;
+declare const index$p_ZERO_HASH: typeof ZERO_HASH;
+declare const index$p_keccak: typeof keccak;
+declare namespace index$p {
+  export { index$p_Blake2b as Blake2b, index$p_WithHash as WithHash, index$p_WithHashAndBytes as WithHashAndBytes, index$p_ZERO_HASH as ZERO_HASH, index$p_keccak as keccak, zero$1 as zero };
+  export type { index$p_Blake2bHash as Blake2bHash, index$p_HASH_SIZE as HASH_SIZE, index$p_KeccakHash as KeccakHash, index$p_OpaqueHash as OpaqueHash, index$p_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$p_TruncatedHash as TruncatedHash };
 }
 
 /** Immutable view of the `HashDictionary`. */
@@ -4464,35 +4493,37 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 }
 
-type index$m_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
-declare const index$m_FixedSizeArray: typeof FixedSizeArray;
-type index$m_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
-declare const index$m_HashDictionary: typeof HashDictionary;
-type index$m_HashSet<V extends OpaqueHash> = HashSet<V>;
-declare const index$m_HashSet: typeof HashSet;
-type index$m_HashWithZeroedBit<T extends OpaqueHash> = HashWithZeroedBit<T>;
-type index$m_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
-type index$m_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
-type index$m_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
-type index$m_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
-type index$m_KeyMapper<K> = KeyMapper<K>;
-type index$m_KeyMappers<TKeys extends readonly unknown[]> = KeyMappers<TKeys>;
-type index$m_KnownSize<T, F extends string> = KnownSize<T, F>;
-type index$m_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
-type index$m_KnownSizeId<X> = KnownSizeId<X>;
-type index$m_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
-declare const index$m_MultiMap: typeof MultiMap;
-type index$m_NestedMaps<TKeys extends readonly unknown[], TValue> = NestedMaps<TKeys, TValue>;
-type index$m_SortedArray<V> = SortedArray<V>;
-declare const index$m_SortedArray: typeof SortedArray;
-type index$m_SortedSet<V> = SortedSet<V>;
-declare const index$m_SortedSet: typeof SortedSet;
-type index$m_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
-declare const index$m_TruncatedHashDictionary: typeof TruncatedHashDictionary;
-declare const index$m_asKnownSize: typeof asKnownSize;
-declare namespace index$m {
-  export { index$m_FixedSizeArray as FixedSizeArray, index$m_HashDictionary as HashDictionary, index$m_HashSet as HashSet, index$m_MultiMap as MultiMap, index$m_SortedArray as SortedArray, index$m_SortedSet as SortedSet, index$m_TruncatedHashDictionary as TruncatedHashDictionary, index$m_asKnownSize as asKnownSize };
-  export type { index$m_HashWithZeroedBit as HashWithZeroedBit, index$m_ImmutableHashDictionary as ImmutableHashDictionary, index$m_ImmutableHashSet as ImmutableHashSet, index$m_ImmutableSortedArray as ImmutableSortedArray, index$m_ImmutableSortedSet as ImmutableSortedSet, index$m_KeyMapper as KeyMapper, index$m_KeyMappers as KeyMappers, index$m_KnownSize as KnownSize, index$m_KnownSizeArray as KnownSizeArray, index$m_KnownSizeId as KnownSizeId, index$m_NestedMaps as NestedMaps };
+type index$o_ArrayView<T> = ArrayView<T>;
+declare const index$o_ArrayView: typeof ArrayView;
+type index$o_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
+declare const index$o_FixedSizeArray: typeof FixedSizeArray;
+type index$o_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
+declare const index$o_HashDictionary: typeof HashDictionary;
+type index$o_HashSet<V extends OpaqueHash> = HashSet<V>;
+declare const index$o_HashSet: typeof HashSet;
+type index$o_HashWithZeroedBit<T extends OpaqueHash> = HashWithZeroedBit<T>;
+type index$o_ImmutableHashDictionary<K extends OpaqueHash, V> = ImmutableHashDictionary<K, V>;
+type index$o_ImmutableHashSet<V extends OpaqueHash> = ImmutableHashSet<V>;
+type index$o_ImmutableSortedArray<V> = ImmutableSortedArray<V>;
+type index$o_ImmutableSortedSet<V> = ImmutableSortedSet<V>;
+type index$o_KeyMapper<K> = KeyMapper<K>;
+type index$o_KeyMappers<TKeys extends readonly unknown[]> = KeyMappers<TKeys>;
+type index$o_KnownSize<T, F extends string> = KnownSize<T, F>;
+type index$o_KnownSizeArray<T, F extends string> = KnownSizeArray<T, F>;
+type index$o_KnownSizeId<X> = KnownSizeId<X>;
+type index$o_MultiMap<TKeys extends readonly unknown[], TValue> = MultiMap<TKeys, TValue>;
+declare const index$o_MultiMap: typeof MultiMap;
+type index$o_NestedMaps<TKeys extends readonly unknown[], TValue> = NestedMaps<TKeys, TValue>;
+type index$o_SortedArray<V> = SortedArray<V>;
+declare const index$o_SortedArray: typeof SortedArray;
+type index$o_SortedSet<V> = SortedSet<V>;
+declare const index$o_SortedSet: typeof SortedSet;
+type index$o_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDictionary<T, V>;
+declare const index$o_TruncatedHashDictionary: typeof TruncatedHashDictionary;
+declare const index$o_asKnownSize: typeof asKnownSize;
+declare namespace index$o {
+  export { index$o_ArrayView as ArrayView, index$o_FixedSizeArray as FixedSizeArray, index$o_HashDictionary as HashDictionary, index$o_HashSet as HashSet, index$o_MultiMap as MultiMap, index$o_SortedArray as SortedArray, index$o_SortedSet as SortedSet, index$o_TruncatedHashDictionary as TruncatedHashDictionary, index$o_asKnownSize as asKnownSize };
+  export type { index$o_HashWithZeroedBit as HashWithZeroedBit, index$o_ImmutableHashDictionary as ImmutableHashDictionary, index$o_ImmutableHashSet as ImmutableHashSet, index$o_ImmutableSortedArray as ImmutableSortedArray, index$o_ImmutableSortedSet as ImmutableSortedSet, index$o_KeyMapper as KeyMapper, index$o_KeyMappers as KeyMappers, index$o_KnownSize as KnownSize, index$o_KnownSizeArray as KnownSizeArray, index$o_KnownSizeId as KnownSizeId, index$o_NestedMaps as NestedMaps };
 }
 
 declare namespace bandersnatch_d_exports {
@@ -4720,7 +4751,7 @@ declare async function verify<T extends BytesBlob>(input: Input<T>[]): Promise<b
     (acc, { message, key, signature }) => acc + key.length + signature.length + message.length + 1,
     0,
   );
-  const data = new Uint8Array(dataLength);
+  const data = safeAllocUint8Array(dataLength);
 
   let offset = 0;
 
@@ -4810,22 +4841,16 @@ declare function trivialSeed(s: U32): KeySeed {
  * Derives a Ed25519 secret key from a seed.
  * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
  */
-declare function deriveEd25519SecretKey(
-  seed: KeySeed,
-  allocator: SimpleAllocator = new SimpleAllocator(),
-): Ed25519SecretSeed {
-  return blake2b.hashBytes(BytesBlob.blobFromParts([ED25519_SECRET_KEY.raw, seed.raw]), allocator).asOpaque();
+declare function deriveEd25519SecretKey(seed: KeySeed, blake2b: Blake2b): Ed25519SecretSeed {
+  return blake2b.hashBytes(BytesBlob.blobFromParts([ED25519_SECRET_KEY.raw, seed.raw])).asOpaque();
 }
 
 /**
  * Derives a Bandersnatch secret key from a seed.
  * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
  */
-declare function deriveBandersnatchSecretKey(
-  seed: KeySeed,
-  allocator: SimpleAllocator = new SimpleAllocator(),
-): BandersnatchSecretSeed {
-  return blake2b.hashBytes(BytesBlob.blobFromParts([BANDERSNATCH_SECRET_KEY.raw, seed.raw]), allocator).asOpaque();
+declare function deriveBandersnatchSecretKey(seed: KeySeed, blake2b: Blake2b): BandersnatchSecretSeed {
+  return blake2b.hashBytes(BytesBlob.blobFromParts([BANDERSNATCH_SECRET_KEY.raw, seed.raw])).asOpaque();
 }
 
 /**
@@ -4858,32 +4883,32 @@ declare namespace keyDerivation {
   export type { keyDerivation_BandersnatchSecretSeed as BandersnatchSecretSeed, keyDerivation_Ed25519SecretSeed as Ed25519SecretSeed, keyDerivation_KeySeed as KeySeed, keyDerivation_SEED_SIZE as SEED_SIZE };
 }
 
-type index$l_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
-type index$l_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
-type index$l_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
-type index$l_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
-type index$l_BLS_KEY_BYTES = BLS_KEY_BYTES;
-type index$l_BandersnatchKey = BandersnatchKey;
-type index$l_BandersnatchProof = BandersnatchProof;
-type index$l_BandersnatchRingRoot = BandersnatchRingRoot;
-type index$l_BandersnatchSecretSeed = BandersnatchSecretSeed;
-type index$l_BandersnatchVrfSignature = BandersnatchVrfSignature;
-type index$l_BlsKey = BlsKey;
-type index$l_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
-type index$l_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
-type index$l_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
-type index$l_Ed25519Key = Ed25519Key;
-type index$l_Ed25519Pair = Ed25519Pair;
-declare const index$l_Ed25519Pair: typeof Ed25519Pair;
-type index$l_Ed25519SecretSeed = Ed25519SecretSeed;
-type index$l_Ed25519Signature = Ed25519Signature;
-type index$l_SEED_SIZE = SEED_SIZE;
-declare const index$l_bandersnatch: typeof bandersnatch;
-declare const index$l_ed25519: typeof ed25519;
-declare const index$l_keyDerivation: typeof keyDerivation;
-declare namespace index$l {
-  export { index$l_Ed25519Pair as Ed25519Pair, index$l_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$l_ed25519 as ed25519, initAll as initWasm, index$l_keyDerivation as keyDerivation };
-  export type { index$l_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$l_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$l_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$l_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$l_BLS_KEY_BYTES as BLS_KEY_BYTES, index$l_BandersnatchKey as BandersnatchKey, index$l_BandersnatchProof as BandersnatchProof, index$l_BandersnatchRingRoot as BandersnatchRingRoot, index$l_BandersnatchSecretSeed as BandersnatchSecretSeed, index$l_BandersnatchVrfSignature as BandersnatchVrfSignature, index$l_BlsKey as BlsKey, index$l_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$l_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$l_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$l_Ed25519Key as Ed25519Key, index$l_Ed25519SecretSeed as Ed25519SecretSeed, index$l_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$l_SEED_SIZE as SEED_SIZE };
+type index$n_BANDERSNATCH_KEY_BYTES = BANDERSNATCH_KEY_BYTES;
+type index$n_BANDERSNATCH_PROOF_BYTES = BANDERSNATCH_PROOF_BYTES;
+type index$n_BANDERSNATCH_RING_ROOT_BYTES = BANDERSNATCH_RING_ROOT_BYTES;
+type index$n_BANDERSNATCH_VRF_SIGNATURE_BYTES = BANDERSNATCH_VRF_SIGNATURE_BYTES;
+type index$n_BLS_KEY_BYTES = BLS_KEY_BYTES;
+type index$n_BandersnatchKey = BandersnatchKey;
+type index$n_BandersnatchProof = BandersnatchProof;
+type index$n_BandersnatchRingRoot = BandersnatchRingRoot;
+type index$n_BandersnatchSecretSeed = BandersnatchSecretSeed;
+type index$n_BandersnatchVrfSignature = BandersnatchVrfSignature;
+type index$n_BlsKey = BlsKey;
+type index$n_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
+type index$n_ED25519_PRIV_KEY_BYTES = ED25519_PRIV_KEY_BYTES;
+type index$n_ED25519_SIGNATURE_BYTES = ED25519_SIGNATURE_BYTES;
+type index$n_Ed25519Key = Ed25519Key;
+type index$n_Ed25519Pair = Ed25519Pair;
+declare const index$n_Ed25519Pair: typeof Ed25519Pair;
+type index$n_Ed25519SecretSeed = Ed25519SecretSeed;
+type index$n_Ed25519Signature = Ed25519Signature;
+type index$n_SEED_SIZE = SEED_SIZE;
+declare const index$n_bandersnatch: typeof bandersnatch;
+declare const index$n_ed25519: typeof ed25519;
+declare const index$n_keyDerivation: typeof keyDerivation;
+declare namespace index$n {
+  export { index$n_Ed25519Pair as Ed25519Pair, index$n_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$n_ed25519 as ed25519, initAll as initWasm, index$n_keyDerivation as keyDerivation };
+  export type { index$n_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$n_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$n_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$n_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$n_BLS_KEY_BYTES as BLS_KEY_BYTES, index$n_BandersnatchKey as BandersnatchKey, index$n_BandersnatchProof as BandersnatchProof, index$n_BandersnatchRingRoot as BandersnatchRingRoot, index$n_BandersnatchSecretSeed as BandersnatchSecretSeed, index$n_BandersnatchVrfSignature as BandersnatchVrfSignature, index$n_BlsKey as BlsKey, index$n_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$n_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$n_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$n_Ed25519Key as Ed25519Key, index$n_Ed25519SecretSeed as Ed25519SecretSeed, index$n_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$n_SEED_SIZE as SEED_SIZE };
 }
 
 /**
@@ -5080,24 +5105,24 @@ declare class Bootnode implements PeerAddress {
   }
 }
 
-type index$k_Bootnode = Bootnode;
-declare const index$k_Bootnode: typeof Bootnode;
-type index$k_ChainSpec = ChainSpec;
-declare const index$k_ChainSpec: typeof ChainSpec;
-declare const index$k_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
-declare const index$k_EST_CORES: typeof EST_CORES;
-declare const index$k_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
-declare const index$k_EST_VALIDATORS: typeof EST_VALIDATORS;
-declare const index$k_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
-type index$k_PeerAddress = PeerAddress;
-type index$k_PeerId = PeerId;
-type index$k_WorkerConfig = WorkerConfig;
-declare const index$k_WorkerConfig: typeof WorkerConfig;
-declare const index$k_fullChainSpec: typeof fullChainSpec;
-declare const index$k_tinyChainSpec: typeof tinyChainSpec;
-declare namespace index$k {
-  export { index$k_Bootnode as Bootnode, index$k_ChainSpec as ChainSpec, index$k_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$k_EST_CORES as EST_CORES, index$k_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$k_EST_VALIDATORS as EST_VALIDATORS, index$k_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$k_WorkerConfig as WorkerConfig, index$k_fullChainSpec as fullChainSpec, index$k_tinyChainSpec as tinyChainSpec };
-  export type { index$k_PeerAddress as PeerAddress, index$k_PeerId as PeerId };
+type index$m_Bootnode = Bootnode;
+declare const index$m_Bootnode: typeof Bootnode;
+type index$m_ChainSpec = ChainSpec;
+declare const index$m_ChainSpec: typeof ChainSpec;
+declare const index$m_EC_SEGMENT_SIZE: typeof EC_SEGMENT_SIZE;
+declare const index$m_EST_CORES: typeof EST_CORES;
+declare const index$m_EST_EPOCH_LENGTH: typeof EST_EPOCH_LENGTH;
+declare const index$m_EST_VALIDATORS: typeof EST_VALIDATORS;
+declare const index$m_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
+type index$m_PeerAddress = PeerAddress;
+type index$m_PeerId = PeerId;
+type index$m_WorkerConfig = WorkerConfig;
+declare const index$m_WorkerConfig: typeof WorkerConfig;
+declare const index$m_fullChainSpec: typeof fullChainSpec;
+declare const index$m_tinyChainSpec: typeof tinyChainSpec;
+declare namespace index$m {
+  export { index$m_Bootnode as Bootnode, index$m_ChainSpec as ChainSpec, index$m_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$m_EST_CORES as EST_CORES, index$m_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$m_EST_VALIDATORS as EST_VALIDATORS, index$m_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$m_WorkerConfig as WorkerConfig, index$m_fullChainSpec as fullChainSpec, index$m_tinyChainSpec as tinyChainSpec };
+  export type { index$m_PeerAddress as PeerAddress, index$m_PeerId as PeerId };
 }
 
 /**
@@ -6873,72 +6898,92 @@ declare class Block extends WithDebug {
 /** Undecoded View of a [`Block`]. */
 type BlockView = DescribedBy<typeof Block.Codec.View>;
 
-type index$j_Block = Block;
-declare const index$j_Block: typeof Block;
-type index$j_BlockView = BlockView;
-type index$j_CodeHash = CodeHash;
-type index$j_CoreIndex = CoreIndex;
-type index$j_EntropyHash = EntropyHash;
-type index$j_Epoch = Epoch;
-type index$j_EpochMarker = EpochMarker;
-declare const index$j_EpochMarker: typeof EpochMarker;
-type index$j_EpochMarkerView = EpochMarkerView;
-type index$j_Extrinsic = Extrinsic;
-declare const index$j_Extrinsic: typeof Extrinsic;
-type index$j_ExtrinsicHash = ExtrinsicHash;
-type index$j_ExtrinsicView = ExtrinsicView;
-type index$j_Header = Header;
-declare const index$j_Header: typeof Header;
-type index$j_HeaderHash = HeaderHash;
-type index$j_HeaderView = HeaderView;
-type index$j_HeaderViewWithHash = HeaderViewWithHash;
-declare const index$j_HeaderViewWithHash: typeof HeaderViewWithHash;
-declare const index$j_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
-type index$j_PerEpochBlock<T> = PerEpochBlock<T>;
-type index$j_PerValidator<T> = PerValidator<T>;
-type index$j_SEGMENT_BYTES = SEGMENT_BYTES;
-type index$j_Segment = Segment;
-type index$j_SegmentIndex = SegmentIndex;
-type index$j_ServiceGas = ServiceGas;
-type index$j_ServiceId = ServiceId;
-type index$j_StateRootHash = StateRootHash;
-type index$j_TicketsMarker = TicketsMarker;
-declare const index$j_TicketsMarker: typeof TicketsMarker;
-type index$j_TicketsMarkerView = TicketsMarkerView;
-type index$j_TimeSlot = TimeSlot;
-type index$j_ValidatorIndex = ValidatorIndex;
-type index$j_ValidatorKeys = ValidatorKeys;
-declare const index$j_ValidatorKeys: typeof ValidatorKeys;
-declare const index$j_W_E: typeof W_E;
-declare const index$j_W_S: typeof W_S;
-type index$j_WorkReportHash = WorkReportHash;
-declare const index$j_assurances: typeof assurances;
-declare const index$j_codecPerEpochBlock: typeof codecPerEpochBlock;
-declare const index$j_codecPerValidator: typeof codecPerValidator;
-declare const index$j_disputes: typeof disputes;
-declare const index$j_encodeUnsealedHeader: typeof encodeUnsealedHeader;
-declare const index$j_guarantees: typeof guarantees;
-declare const index$j_headerViewWithHashCodec: typeof headerViewWithHashCodec;
-declare const index$j_legacyDescriptor: typeof legacyDescriptor;
-declare const index$j_preimage: typeof preimage;
-declare const index$j_refineContext: typeof refineContext;
-declare const index$j_tickets: typeof tickets;
-declare const index$j_tryAsCoreIndex: typeof tryAsCoreIndex;
-declare const index$j_tryAsEpoch: typeof tryAsEpoch;
-declare const index$j_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
-declare const index$j_tryAsPerValidator: typeof tryAsPerValidator;
-declare const index$j_tryAsSegmentIndex: typeof tryAsSegmentIndex;
-declare const index$j_tryAsServiceGas: typeof tryAsServiceGas;
-declare const index$j_tryAsServiceId: typeof tryAsServiceId;
-declare const index$j_tryAsTimeSlot: typeof tryAsTimeSlot;
-declare const index$j_tryAsValidatorIndex: typeof tryAsValidatorIndex;
-declare const index$j_workItem: typeof workItem;
-declare const index$j_workPackage: typeof workPackage;
-declare const index$j_workReport: typeof workReport;
-declare const index$j_workResult: typeof workResult;
-declare namespace index$j {
-  export { index$j_Block as Block, index$j_EpochMarker as EpochMarker, index$j_Extrinsic as Extrinsic, index$j_Header as Header, index$j_HeaderViewWithHash as HeaderViewWithHash, index$j_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$j_TicketsMarker as TicketsMarker, index$j_ValidatorKeys as ValidatorKeys, index$j_W_E as W_E, index$j_W_S as W_S, index$j_assurances as assurances, index$j_codecPerEpochBlock as codecPerEpochBlock, index$j_codecPerValidator as codecPerValidator, codec as codecUtils, index$j_disputes as disputes, index$j_encodeUnsealedHeader as encodeUnsealedHeader, index$j_guarantees as guarantees, index$j_headerViewWithHashCodec as headerViewWithHashCodec, index$j_legacyDescriptor as legacyDescriptor, index$j_preimage as preimage, index$j_refineContext as refineContext, index$j_tickets as tickets, index$j_tryAsCoreIndex as tryAsCoreIndex, index$j_tryAsEpoch as tryAsEpoch, index$j_tryAsPerEpochBlock as tryAsPerEpochBlock, index$j_tryAsPerValidator as tryAsPerValidator, index$j_tryAsSegmentIndex as tryAsSegmentIndex, index$j_tryAsServiceGas as tryAsServiceGas, index$j_tryAsServiceId as tryAsServiceId, index$j_tryAsTimeSlot as tryAsTimeSlot, index$j_tryAsValidatorIndex as tryAsValidatorIndex, index$j_workItem as workItem, index$j_workPackage as workPackage, index$j_workReport as workReport, index$j_workResult as workResult };
-  export type { index$j_BlockView as BlockView, index$j_CodeHash as CodeHash, index$j_CoreIndex as CoreIndex, index$j_EntropyHash as EntropyHash, index$j_Epoch as Epoch, index$j_EpochMarkerView as EpochMarkerView, index$j_ExtrinsicHash as ExtrinsicHash, index$j_ExtrinsicView as ExtrinsicView, index$j_HeaderHash as HeaderHash, index$j_HeaderView as HeaderView, index$j_PerEpochBlock as PerEpochBlock, index$j_PerValidator as PerValidator, index$j_SEGMENT_BYTES as SEGMENT_BYTES, index$j_Segment as Segment, index$j_SegmentIndex as SegmentIndex, index$j_ServiceGas as ServiceGas, index$j_ServiceId as ServiceId, index$j_StateRootHash as StateRootHash, index$j_TicketsMarkerView as TicketsMarkerView, index$j_TimeSlot as TimeSlot, index$j_ValidatorIndex as ValidatorIndex, index$j_WorkReportHash as WorkReportHash };
+declare function emptyBlock(slot: TimeSlot = tryAsTimeSlot(0)) {
+  const header = Header.empty();
+  header.timeSlotIndex = slot;
+  return Block.create({
+    header,
+    extrinsic: Extrinsic.create({
+      tickets: asKnownSize([]),
+      preimages: [],
+      assurances: asKnownSize([]),
+      guarantees: asKnownSize([]),
+      disputes: {
+        verdicts: [],
+        culprits: [],
+        faults: [],
+      },
+    }),
+  });
+}
+
+type index$l_Block = Block;
+declare const index$l_Block: typeof Block;
+type index$l_BlockView = BlockView;
+type index$l_CodeHash = CodeHash;
+type index$l_CoreIndex = CoreIndex;
+type index$l_EntropyHash = EntropyHash;
+type index$l_Epoch = Epoch;
+type index$l_EpochMarker = EpochMarker;
+declare const index$l_EpochMarker: typeof EpochMarker;
+type index$l_EpochMarkerView = EpochMarkerView;
+type index$l_Extrinsic = Extrinsic;
+declare const index$l_Extrinsic: typeof Extrinsic;
+type index$l_ExtrinsicHash = ExtrinsicHash;
+type index$l_ExtrinsicView = ExtrinsicView;
+type index$l_Header = Header;
+declare const index$l_Header: typeof Header;
+type index$l_HeaderHash = HeaderHash;
+type index$l_HeaderView = HeaderView;
+type index$l_HeaderViewWithHash = HeaderViewWithHash;
+declare const index$l_HeaderViewWithHash: typeof HeaderViewWithHash;
+declare const index$l_MAX_NUMBER_OF_SEGMENTS: typeof MAX_NUMBER_OF_SEGMENTS;
+type index$l_PerEpochBlock<T> = PerEpochBlock<T>;
+type index$l_PerValidator<T> = PerValidator<T>;
+type index$l_SEGMENT_BYTES = SEGMENT_BYTES;
+type index$l_Segment = Segment;
+type index$l_SegmentIndex = SegmentIndex;
+type index$l_ServiceGas = ServiceGas;
+type index$l_ServiceId = ServiceId;
+type index$l_StateRootHash = StateRootHash;
+type index$l_TicketsMarker = TicketsMarker;
+declare const index$l_TicketsMarker: typeof TicketsMarker;
+type index$l_TicketsMarkerView = TicketsMarkerView;
+type index$l_TimeSlot = TimeSlot;
+type index$l_ValidatorIndex = ValidatorIndex;
+type index$l_ValidatorKeys = ValidatorKeys;
+declare const index$l_ValidatorKeys: typeof ValidatorKeys;
+declare const index$l_W_E: typeof W_E;
+declare const index$l_W_S: typeof W_S;
+type index$l_WorkReportHash = WorkReportHash;
+declare const index$l_assurances: typeof assurances;
+declare const index$l_codecPerEpochBlock: typeof codecPerEpochBlock;
+declare const index$l_codecPerValidator: typeof codecPerValidator;
+declare const index$l_disputes: typeof disputes;
+declare const index$l_emptyBlock: typeof emptyBlock;
+declare const index$l_encodeUnsealedHeader: typeof encodeUnsealedHeader;
+declare const index$l_guarantees: typeof guarantees;
+declare const index$l_headerViewWithHashCodec: typeof headerViewWithHashCodec;
+declare const index$l_legacyDescriptor: typeof legacyDescriptor;
+declare const index$l_preimage: typeof preimage;
+declare const index$l_refineContext: typeof refineContext;
+declare const index$l_tickets: typeof tickets;
+declare const index$l_tryAsCoreIndex: typeof tryAsCoreIndex;
+declare const index$l_tryAsEpoch: typeof tryAsEpoch;
+declare const index$l_tryAsPerEpochBlock: typeof tryAsPerEpochBlock;
+declare const index$l_tryAsPerValidator: typeof tryAsPerValidator;
+declare const index$l_tryAsSegmentIndex: typeof tryAsSegmentIndex;
+declare const index$l_tryAsServiceGas: typeof tryAsServiceGas;
+declare const index$l_tryAsServiceId: typeof tryAsServiceId;
+declare const index$l_tryAsTimeSlot: typeof tryAsTimeSlot;
+declare const index$l_tryAsValidatorIndex: typeof tryAsValidatorIndex;
+declare const index$l_workItem: typeof workItem;
+declare const index$l_workPackage: typeof workPackage;
+declare const index$l_workReport: typeof workReport;
+declare const index$l_workResult: typeof workResult;
+declare namespace index$l {
+  export { index$l_Block as Block, index$l_EpochMarker as EpochMarker, index$l_Extrinsic as Extrinsic, index$l_Header as Header, index$l_HeaderViewWithHash as HeaderViewWithHash, index$l_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$l_TicketsMarker as TicketsMarker, index$l_ValidatorKeys as ValidatorKeys, index$l_W_E as W_E, index$l_W_S as W_S, index$l_assurances as assurances, index$l_codecPerEpochBlock as codecPerEpochBlock, index$l_codecPerValidator as codecPerValidator, codec as codecUtils, index$l_disputes as disputes, index$l_emptyBlock as emptyBlock, index$l_encodeUnsealedHeader as encodeUnsealedHeader, index$l_guarantees as guarantees, index$l_headerViewWithHashCodec as headerViewWithHashCodec, index$l_legacyDescriptor as legacyDescriptor, index$l_preimage as preimage, index$l_refineContext as refineContext, index$l_tickets as tickets, index$l_tryAsCoreIndex as tryAsCoreIndex, index$l_tryAsEpoch as tryAsEpoch, index$l_tryAsPerEpochBlock as tryAsPerEpochBlock, index$l_tryAsPerValidator as tryAsPerValidator, index$l_tryAsSegmentIndex as tryAsSegmentIndex, index$l_tryAsServiceGas as tryAsServiceGas, index$l_tryAsServiceId as tryAsServiceId, index$l_tryAsTimeSlot as tryAsTimeSlot, index$l_tryAsValidatorIndex as tryAsValidatorIndex, index$l_workItem as workItem, index$l_workPackage as workPackage, index$l_workReport as workReport, index$l_workResult as workResult };
+  export type { index$l_BlockView as BlockView, index$l_CodeHash as CodeHash, index$l_CoreIndex as CoreIndex, index$l_EntropyHash as EntropyHash, index$l_Epoch as Epoch, index$l_EpochMarkerView as EpochMarkerView, index$l_ExtrinsicHash as ExtrinsicHash, index$l_ExtrinsicView as ExtrinsicView, index$l_HeaderHash as HeaderHash, index$l_HeaderView as HeaderView, index$l_PerEpochBlock as PerEpochBlock, index$l_PerValidator as PerValidator, index$l_SEGMENT_BYTES as SEGMENT_BYTES, index$l_Segment as Segment, index$l_SegmentIndex as SegmentIndex, index$l_ServiceGas as ServiceGas, index$l_ServiceId as ServiceId, index$l_StateRootHash as StateRootHash, index$l_TicketsMarkerView as TicketsMarkerView, index$l_TimeSlot as TimeSlot, index$l_ValidatorIndex as ValidatorIndex, index$l_WorkReportHash as WorkReportHash };
 }
 
 /** A type that can be read from a JSON-parsed object. */
@@ -7236,21 +7281,21 @@ declare namespace json {
   }
 }
 
-type index$i_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
-type index$i_FromJson<T> = FromJson<T>;
-type index$i_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
-type index$i_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
-type index$i_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
-declare const index$i_NO_KEY: typeof NO_KEY;
-type index$i_ObjectFromJson<T> = ObjectFromJson<T>;
-type index$i_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
-declare const index$i_diffKeys: typeof diffKeys;
-import index$i_json = json;
-declare const index$i_parseFromJson: typeof parseFromJson;
-declare const index$i_parseOrThrow: typeof parseOrThrow;
-declare namespace index$i {
-  export { index$i_NO_KEY as NO_KEY, index$i_diffKeys as diffKeys, index$i_json as json, index$i_parseFromJson as parseFromJson, index$i_parseOrThrow as parseOrThrow };
-  export type { index$i_Builder as Builder, index$i_FromJson as FromJson, index$i_FromJsonOptional as FromJsonOptional, index$i_FromJsonPrimitive as FromJsonPrimitive, index$i_FromJsonWithParser as FromJsonWithParser, index$i_ObjectFromJson as ObjectFromJson, index$i_Parser as Parser };
+type index$k_Builder<TFrom, TInto> = Builder<TFrom, TInto>;
+type index$k_FromJson<T> = FromJson<T>;
+type index$k_FromJsonOptional<TInto> = FromJsonOptional<TInto>;
+type index$k_FromJsonPrimitive<T> = FromJsonPrimitive<T>;
+type index$k_FromJsonWithParser<TFrom, TInto> = FromJsonWithParser<TFrom, TInto>;
+declare const index$k_NO_KEY: typeof NO_KEY;
+type index$k_ObjectFromJson<T> = ObjectFromJson<T>;
+type index$k_Parser<TFrom, TInto> = Parser<TFrom, TInto>;
+declare const index$k_diffKeys: typeof diffKeys;
+import index$k_json = json;
+declare const index$k_parseFromJson: typeof parseFromJson;
+declare const index$k_parseOrThrow: typeof parseOrThrow;
+declare namespace index$k {
+  export { index$k_NO_KEY as NO_KEY, index$k_diffKeys as diffKeys, index$k_json as json, index$k_parseFromJson as parseFromJson, index$k_parseOrThrow as parseOrThrow };
+  export type { index$k_Builder as Builder, index$k_FromJson as FromJson, index$k_FromJsonOptional as FromJsonOptional, index$k_FromJsonPrimitive as FromJsonPrimitive, index$k_FromJsonWithParser as FromJsonWithParser, index$k_ObjectFromJson as ObjectFromJson, index$k_Parser as Parser };
 }
 
 declare namespace fromJson {
@@ -7753,52 +7798,52 @@ declare const blockFromJson = (spec: ChainSpec) =>
     ({ header, extrinsic }) => Block.create({ header, extrinsic }),
   );
 
-type index$h_CamelToSnake<S extends string> = CamelToSnake<S>;
-type index$h_JsonCulprit = JsonCulprit;
-type index$h_JsonEpochMarker = JsonEpochMarker;
-type index$h_JsonFault = JsonFault;
-type index$h_JsonHeader = JsonHeader;
-type index$h_JsonJudgement = JsonJudgement;
-type index$h_JsonObject<T> = JsonObject<T>;
-type index$h_JsonRefineContext = JsonRefineContext;
-type index$h_JsonReportGuarantee = JsonReportGuarantee;
-type index$h_JsonVerdict = JsonVerdict;
-type index$h_JsonWorkExecResult = JsonWorkExecResult;
-type index$h_JsonWorkRefineLoad = JsonWorkRefineLoad;
-type index$h_JsonWorkReport = JsonWorkReport;
-type index$h_JsonWorkResult = JsonWorkResult;
-declare const index$h_bandersnatchVrfSignature: typeof bandersnatchVrfSignature;
-declare const index$h_blockFromJson: typeof blockFromJson;
-declare const index$h_culpritFromJson: typeof culpritFromJson;
-declare const index$h_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
-declare const index$h_epochMark: typeof epochMark;
-declare const index$h_faultFromJson: typeof faultFromJson;
-import index$h_fromJson = fromJson;
-declare const index$h_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
-declare const index$h_getAvailabilityAssuranceFromJson: typeof getAvailabilityAssuranceFromJson;
-declare const index$h_getExtrinsicFromJson: typeof getExtrinsicFromJson;
-declare const index$h_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
-declare const index$h_headerFromJson: typeof headerFromJson;
-declare const index$h_judgementFromJson: typeof judgementFromJson;
-declare const index$h_preimageFromJson: typeof preimageFromJson;
-declare const index$h_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
-declare const index$h_refineContextFromJson: typeof refineContextFromJson;
-declare const index$h_reportGuaranteeFromJson: typeof reportGuaranteeFromJson;
-declare const index$h_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
-declare const index$h_ticket: typeof ticket;
-declare const index$h_ticketEnvelopeFromJson: typeof ticketEnvelopeFromJson;
-declare const index$h_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
-declare const index$h_validatorKeysFromJson: typeof validatorKeysFromJson;
-declare const index$h_validatorSignatureFromJson: typeof validatorSignatureFromJson;
-declare const index$h_verdictFromJson: typeof verdictFromJson;
-declare const index$h_workExecResultFromJson: typeof workExecResultFromJson;
-declare const index$h_workPackageSpecFromJson: typeof workPackageSpecFromJson;
-declare const index$h_workRefineLoadFromJson: typeof workRefineLoadFromJson;
-declare const index$h_workReportFromJson: typeof workReportFromJson;
-declare const index$h_workResultFromJson: typeof workResultFromJson;
-declare namespace index$h {
-  export { index$h_bandersnatchVrfSignature as bandersnatchVrfSignature, index$h_blockFromJson as blockFromJson, index$h_culpritFromJson as culpritFromJson, index$h_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$h_epochMark as epochMark, index$h_faultFromJson as faultFromJson, index$h_fromJson as fromJson, index$h_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$h_getAvailabilityAssuranceFromJson as getAvailabilityAssuranceFromJson, index$h_getExtrinsicFromJson as getExtrinsicFromJson, index$h_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$h_headerFromJson as headerFromJson, index$h_judgementFromJson as judgementFromJson, index$h_preimageFromJson as preimageFromJson, index$h_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$h_refineContextFromJson as refineContextFromJson, index$h_reportGuaranteeFromJson as reportGuaranteeFromJson, index$h_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$h_ticket as ticket, index$h_ticketEnvelopeFromJson as ticketEnvelopeFromJson, index$h_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$h_validatorKeysFromJson as validatorKeysFromJson, index$h_validatorSignatureFromJson as validatorSignatureFromJson, index$h_verdictFromJson as verdictFromJson, index$h_workExecResultFromJson as workExecResultFromJson, index$h_workPackageSpecFromJson as workPackageSpecFromJson, index$h_workRefineLoadFromJson as workRefineLoadFromJson, index$h_workReportFromJson as workReportFromJson, index$h_workResultFromJson as workResultFromJson };
-  export type { index$h_CamelToSnake as CamelToSnake, index$h_JsonCulprit as JsonCulprit, index$h_JsonEpochMarker as JsonEpochMarker, index$h_JsonFault as JsonFault, index$h_JsonHeader as JsonHeader, index$h_JsonJudgement as JsonJudgement, index$h_JsonObject as JsonObject, index$h_JsonRefineContext as JsonRefineContext, index$h_JsonReportGuarantee as JsonReportGuarantee, index$h_JsonVerdict as JsonVerdict, index$h_JsonWorkExecResult as JsonWorkExecResult, index$h_JsonWorkRefineLoad as JsonWorkRefineLoad, index$h_JsonWorkReport as JsonWorkReport, index$h_JsonWorkResult as JsonWorkResult };
+type index$j_CamelToSnake<S extends string> = CamelToSnake<S>;
+type index$j_JsonCulprit = JsonCulprit;
+type index$j_JsonEpochMarker = JsonEpochMarker;
+type index$j_JsonFault = JsonFault;
+type index$j_JsonHeader = JsonHeader;
+type index$j_JsonJudgement = JsonJudgement;
+type index$j_JsonObject<T> = JsonObject<T>;
+type index$j_JsonRefineContext = JsonRefineContext;
+type index$j_JsonReportGuarantee = JsonReportGuarantee;
+type index$j_JsonVerdict = JsonVerdict;
+type index$j_JsonWorkExecResult = JsonWorkExecResult;
+type index$j_JsonWorkRefineLoad = JsonWorkRefineLoad;
+type index$j_JsonWorkReport = JsonWorkReport;
+type index$j_JsonWorkResult = JsonWorkResult;
+declare const index$j_bandersnatchVrfSignature: typeof bandersnatchVrfSignature;
+declare const index$j_blockFromJson: typeof blockFromJson;
+declare const index$j_culpritFromJson: typeof culpritFromJson;
+declare const index$j_disputesExtrinsicFromJson: typeof disputesExtrinsicFromJson;
+declare const index$j_epochMark: typeof epochMark;
+declare const index$j_faultFromJson: typeof faultFromJson;
+import index$j_fromJson = fromJson;
+declare const index$j_getAssurancesExtrinsicFromJson: typeof getAssurancesExtrinsicFromJson;
+declare const index$j_getAvailabilityAssuranceFromJson: typeof getAvailabilityAssuranceFromJson;
+declare const index$j_getExtrinsicFromJson: typeof getExtrinsicFromJson;
+declare const index$j_guaranteesExtrinsicFromJson: typeof guaranteesExtrinsicFromJson;
+declare const index$j_headerFromJson: typeof headerFromJson;
+declare const index$j_judgementFromJson: typeof judgementFromJson;
+declare const index$j_preimageFromJson: typeof preimageFromJson;
+declare const index$j_preimagesExtrinsicFromJson: typeof preimagesExtrinsicFromJson;
+declare const index$j_refineContextFromJson: typeof refineContextFromJson;
+declare const index$j_reportGuaranteeFromJson: typeof reportGuaranteeFromJson;
+declare const index$j_segmentRootLookupItemFromJson: typeof segmentRootLookupItemFromJson;
+declare const index$j_ticket: typeof ticket;
+declare const index$j_ticketEnvelopeFromJson: typeof ticketEnvelopeFromJson;
+declare const index$j_ticketsExtrinsicFromJson: typeof ticketsExtrinsicFromJson;
+declare const index$j_validatorKeysFromJson: typeof validatorKeysFromJson;
+declare const index$j_validatorSignatureFromJson: typeof validatorSignatureFromJson;
+declare const index$j_verdictFromJson: typeof verdictFromJson;
+declare const index$j_workExecResultFromJson: typeof workExecResultFromJson;
+declare const index$j_workPackageSpecFromJson: typeof workPackageSpecFromJson;
+declare const index$j_workRefineLoadFromJson: typeof workRefineLoadFromJson;
+declare const index$j_workReportFromJson: typeof workReportFromJson;
+declare const index$j_workResultFromJson: typeof workResultFromJson;
+declare namespace index$j {
+  export { index$j_bandersnatchVrfSignature as bandersnatchVrfSignature, index$j_blockFromJson as blockFromJson, index$j_culpritFromJson as culpritFromJson, index$j_disputesExtrinsicFromJson as disputesExtrinsicFromJson, index$j_epochMark as epochMark, index$j_faultFromJson as faultFromJson, index$j_fromJson as fromJson, index$j_getAssurancesExtrinsicFromJson as getAssurancesExtrinsicFromJson, index$j_getAvailabilityAssuranceFromJson as getAvailabilityAssuranceFromJson, index$j_getExtrinsicFromJson as getExtrinsicFromJson, index$j_guaranteesExtrinsicFromJson as guaranteesExtrinsicFromJson, index$j_headerFromJson as headerFromJson, index$j_judgementFromJson as judgementFromJson, index$j_preimageFromJson as preimageFromJson, index$j_preimagesExtrinsicFromJson as preimagesExtrinsicFromJson, index$j_refineContextFromJson as refineContextFromJson, index$j_reportGuaranteeFromJson as reportGuaranteeFromJson, index$j_segmentRootLookupItemFromJson as segmentRootLookupItemFromJson, index$j_ticket as ticket, index$j_ticketEnvelopeFromJson as ticketEnvelopeFromJson, index$j_ticketsExtrinsicFromJson as ticketsExtrinsicFromJson, index$j_validatorKeysFromJson as validatorKeysFromJson, index$j_validatorSignatureFromJson as validatorSignatureFromJson, index$j_verdictFromJson as verdictFromJson, index$j_workExecResultFromJson as workExecResultFromJson, index$j_workPackageSpecFromJson as workPackageSpecFromJson, index$j_workRefineLoadFromJson as workRefineLoadFromJson, index$j_workReportFromJson as workReportFromJson, index$j_workResultFromJson as workResultFromJson };
+  export type { index$j_CamelToSnake as CamelToSnake, index$j_JsonCulprit as JsonCulprit, index$j_JsonEpochMarker as JsonEpochMarker, index$j_JsonFault as JsonFault, index$j_JsonHeader as JsonHeader, index$j_JsonJudgement as JsonJudgement, index$j_JsonObject as JsonObject, index$j_JsonRefineContext as JsonRefineContext, index$j_JsonReportGuarantee as JsonReportGuarantee, index$j_JsonVerdict as JsonVerdict, index$j_JsonWorkExecResult as JsonWorkExecResult, index$j_JsonWorkRefineLoad as JsonWorkRefineLoad, index$j_JsonWorkReport as JsonWorkReport, index$j_JsonWorkResult as JsonWorkResult };
 }
 
 declare function parseBootnode(v: string): Bootnode {
@@ -8046,16 +8091,16 @@ declare class Logger {
   }
 }
 
-type index$g_Level = Level;
-declare const index$g_Level: typeof Level;
-type index$g_Logger = Logger;
-declare const index$g_Logger: typeof Logger;
-declare const index$g_parseLoggerOptions: typeof parseLoggerOptions;
-declare namespace index$g {
+type index$i_Level = Level;
+declare const index$i_Level: typeof Level;
+type index$i_Logger = Logger;
+declare const index$i_Logger: typeof Logger;
+declare const index$i_parseLoggerOptions: typeof parseLoggerOptions;
+declare namespace index$i {
   export {
-    index$g_Level as Level,
-    index$g_Logger as Logger,
-    index$g_parseLoggerOptions as parseLoggerOptions,
+    index$i_Level as Level,
+    index$i_Logger as Logger,
+    index$i_parseLoggerOptions as parseLoggerOptions,
   };
 }
 
@@ -8078,7 +8123,7 @@ declare class AuthorshipOptions {
   ) {}
 }
 
-declare const logger$1 = Logger.new(import.meta.filename, "config");
+declare const logger$2 = Logger.new(import.meta.filename, "config");
 
 /** Development config. Will accept unsealed blocks for now. */
 declare const DEV_CONFIG = "dev";
@@ -8160,30 +8205,30 @@ declare function loadConfig(configPath: string): NodeConfiguration {
   }
 }
 
-declare const index$f_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
-declare const index$f_DEV_CONFIG: typeof DEV_CONFIG;
-type index$f_JipChainSpec = JipChainSpec;
-declare const index$f_JipChainSpec: typeof JipChainSpec;
-type index$f_KnownChainSpec = KnownChainSpec;
-declare const index$f_KnownChainSpec: typeof KnownChainSpec;
-declare const index$f_NODE_DEFAULTS: typeof NODE_DEFAULTS;
-type index$f_NodeConfiguration = NodeConfiguration;
-declare const index$f_NodeConfiguration: typeof NodeConfiguration;
-declare const index$f_knownChainSpecFromJson: typeof knownChainSpecFromJson;
-declare const index$f_loadConfig: typeof loadConfig;
-declare const index$f_parseBootnode: typeof parseBootnode;
-declare namespace index$f {
+declare const index$h_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
+declare const index$h_DEV_CONFIG: typeof DEV_CONFIG;
+type index$h_JipChainSpec = JipChainSpec;
+declare const index$h_JipChainSpec: typeof JipChainSpec;
+type index$h_KnownChainSpec = KnownChainSpec;
+declare const index$h_KnownChainSpec: typeof KnownChainSpec;
+declare const index$h_NODE_DEFAULTS: typeof NODE_DEFAULTS;
+type index$h_NodeConfiguration = NodeConfiguration;
+declare const index$h_NodeConfiguration: typeof NodeConfiguration;
+declare const index$h_knownChainSpecFromJson: typeof knownChainSpecFromJson;
+declare const index$h_loadConfig: typeof loadConfig;
+declare const index$h_parseBootnode: typeof parseBootnode;
+declare namespace index$h {
   export {
-    index$f_DEFAULT_CONFIG as DEFAULT_CONFIG,
-    index$f_DEV_CONFIG as DEV_CONFIG,
-    index$f_JipChainSpec as JipChainSpec,
-    index$f_KnownChainSpec as KnownChainSpec,
-    index$f_NODE_DEFAULTS as NODE_DEFAULTS,
-    index$f_NodeConfiguration as NodeConfiguration,
-    index$f_knownChainSpecFromJson as knownChainSpecFromJson,
-    index$f_loadConfig as loadConfig,
-    logger$1 as logger,
-    index$f_parseBootnode as parseBootnode,
+    index$h_DEFAULT_CONFIG as DEFAULT_CONFIG,
+    index$h_DEV_CONFIG as DEV_CONFIG,
+    index$h_JipChainSpec as JipChainSpec,
+    index$h_KnownChainSpec as KnownChainSpec,
+    index$h_NODE_DEFAULTS as NODE_DEFAULTS,
+    index$h_NodeConfiguration as NodeConfiguration,
+    index$h_knownChainSpecFromJson as knownChainSpecFromJson,
+    index$h_loadConfig as loadConfig,
+    logger$2 as logger,
+    index$h_parseBootnode as parseBootnode,
   };
 }
 
@@ -8338,7 +8383,7 @@ declare enum NodeType {
 declare class TrieNode {
   constructor(
     /** Exactly 512 bits / 64 bytes */
-    public readonly raw: Uint8Array = new Uint8Array(TRIE_NODE_BYTES),
+    public readonly raw: Uint8Array = safeAllocUint8Array(TRIE_NODE_BYTES),
   ) {}
 
   /** Returns the type of the node */
@@ -8970,43 +9015,43 @@ declare const bitLookup = [
   [0b00000000, 8],
 ];
 
-type index$e_BranchNode = BranchNode;
-declare const index$e_BranchNode: typeof BranchNode;
-type index$e_InMemoryTrie = InMemoryTrie;
-declare const index$e_InMemoryTrie: typeof InMemoryTrie;
-type index$e_InputKey = InputKey;
-type index$e_LeafNode = LeafNode;
-declare const index$e_LeafNode: typeof LeafNode;
-type index$e_NodeType = NodeType;
-declare const index$e_NodeType: typeof NodeType;
-type index$e_NodesDb = NodesDb;
-declare const index$e_NodesDb: typeof NodesDb;
-declare const index$e_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
-declare const index$e_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
-type index$e_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
-type index$e_TraversedPath = TraversedPath;
-declare const index$e_TraversedPath: typeof TraversedPath;
-type index$e_TrieHasher = TrieHasher;
-type index$e_TrieNode = TrieNode;
-declare const index$e_TrieNode: typeof TrieNode;
-type index$e_TrieNodeHash = TrieNodeHash;
-type index$e_TruncatedStateKey = TruncatedStateKey;
-type index$e_ValueHash = ValueHash;
-type index$e_WriteableNodesDb = WriteableNodesDb;
-declare const index$e_WriteableNodesDb: typeof WriteableNodesDb;
-declare const index$e_bitLookup: typeof bitLookup;
-declare const index$e_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
-declare const index$e_findNodeToReplace: typeof findNodeToReplace;
-declare const index$e_findSharedPrefix: typeof findSharedPrefix;
-declare const index$e_getBit: typeof getBit;
-declare const index$e_leafComparator: typeof leafComparator;
-declare const index$e_parseInputKey: typeof parseInputKey;
-declare const index$e_trieInsert: typeof trieInsert;
-declare const index$e_trieStringify: typeof trieStringify;
-declare const index$e_zero: typeof zero;
-declare namespace index$e {
-  export { index$e_BranchNode as BranchNode, index$e_InMemoryTrie as InMemoryTrie, index$e_LeafNode as LeafNode, index$e_NodeType as NodeType, index$e_NodesDb as NodesDb, index$e_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$e_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$e_TraversedPath as TraversedPath, index$e_TrieNode as TrieNode, index$e_WriteableNodesDb as WriteableNodesDb, index$e_bitLookup as bitLookup, index$e_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$e_findNodeToReplace as findNodeToReplace, index$e_findSharedPrefix as findSharedPrefix, index$e_getBit as getBit, index$e_leafComparator as leafComparator, index$e_parseInputKey as parseInputKey, index$e_trieInsert as trieInsert, index$e_trieStringify as trieStringify, index$e_zero as zero };
-  export type { index$e_InputKey as InputKey, StateKey$1 as StateKey, index$e_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$e_TrieHasher as TrieHasher, index$e_TrieNodeHash as TrieNodeHash, index$e_TruncatedStateKey as TruncatedStateKey, index$e_ValueHash as ValueHash };
+type index$g_BranchNode = BranchNode;
+declare const index$g_BranchNode: typeof BranchNode;
+type index$g_InMemoryTrie = InMemoryTrie;
+declare const index$g_InMemoryTrie: typeof InMemoryTrie;
+type index$g_InputKey = InputKey;
+type index$g_LeafNode = LeafNode;
+declare const index$g_LeafNode: typeof LeafNode;
+type index$g_NodeType = NodeType;
+declare const index$g_NodeType: typeof NodeType;
+type index$g_NodesDb = NodesDb;
+declare const index$g_NodesDb: typeof NodesDb;
+declare const index$g_TRIE_NODE_BYTES: typeof TRIE_NODE_BYTES;
+declare const index$g_TRUNCATED_KEY_BITS: typeof TRUNCATED_KEY_BITS;
+type index$g_TRUNCATED_KEY_BYTES = TRUNCATED_KEY_BYTES;
+type index$g_TraversedPath = TraversedPath;
+declare const index$g_TraversedPath: typeof TraversedPath;
+type index$g_TrieHasher = TrieHasher;
+type index$g_TrieNode = TrieNode;
+declare const index$g_TrieNode: typeof TrieNode;
+type index$g_TrieNodeHash = TrieNodeHash;
+type index$g_TruncatedStateKey = TruncatedStateKey;
+type index$g_ValueHash = ValueHash;
+type index$g_WriteableNodesDb = WriteableNodesDb;
+declare const index$g_WriteableNodesDb: typeof WriteableNodesDb;
+declare const index$g_bitLookup: typeof bitLookup;
+declare const index$g_createSubtreeForBothLeaves: typeof createSubtreeForBothLeaves;
+declare const index$g_findNodeToReplace: typeof findNodeToReplace;
+declare const index$g_findSharedPrefix: typeof findSharedPrefix;
+declare const index$g_getBit: typeof getBit;
+declare const index$g_leafComparator: typeof leafComparator;
+declare const index$g_parseInputKey: typeof parseInputKey;
+declare const index$g_trieInsert: typeof trieInsert;
+declare const index$g_trieStringify: typeof trieStringify;
+declare const index$g_zero: typeof zero;
+declare namespace index$g {
+  export { index$g_BranchNode as BranchNode, index$g_InMemoryTrie as InMemoryTrie, index$g_LeafNode as LeafNode, index$g_NodeType as NodeType, index$g_NodesDb as NodesDb, index$g_TRIE_NODE_BYTES as TRIE_NODE_BYTES, index$g_TRUNCATED_KEY_BITS as TRUNCATED_KEY_BITS, index$g_TraversedPath as TraversedPath, index$g_TrieNode as TrieNode, index$g_WriteableNodesDb as WriteableNodesDb, index$g_bitLookup as bitLookup, index$g_createSubtreeForBothLeaves as createSubtreeForBothLeaves, index$g_findNodeToReplace as findNodeToReplace, index$g_findSharedPrefix as findSharedPrefix, index$g_getBit as getBit, index$g_leafComparator as leafComparator, index$g_parseInputKey as parseInputKey, index$g_trieInsert as trieInsert, index$g_trieStringify as trieStringify, index$g_zero as zero };
+  export type { index$g_InputKey as InputKey, StateKey$1 as StateKey, index$g_TRUNCATED_KEY_BYTES as TRUNCATED_KEY_BYTES, index$g_TrieHasher as TrieHasher, index$g_TrieNodeHash as TrieNodeHash, index$g_TruncatedStateKey as TruncatedStateKey, index$g_ValueHash as ValueHash };
 }
 
 /**
@@ -9076,21 +9121,6 @@ declare function accumulationOutputComparator(a: AccumulationOutput, b: Accumula
   return Ordering.Equal;
 }
 
-declare const codecWithHash = <T, V, H extends OpaqueHash>(val: Descriptor<T, V>): Descriptor<WithHash<H, T>, V> =>
-  Descriptor.withView(
-    val.name,
-    val.sizeHint,
-    (e, elem) => val.encode(e, elem.data),
-    (d): WithHash<H, T> => {
-      const decoder2 = d.clone();
-      const encoded = val.skipEncoded(decoder2);
-      const hash = blake2b.hashBytes(encoded);
-      return new WithHash(hash.asOpaque(), val.decode(d));
-    },
-    val.skip,
-    val.View,
-  );
-
 /**
  * Assignment of particular work report to a core.
  *
@@ -9101,7 +9131,7 @@ declare const codecWithHash = <T, V, H extends OpaqueHash>(val: Descriptor<T, V>
  */
 declare class AvailabilityAssignment extends WithDebug {
   static Codec = codec.Class(AvailabilityAssignment, {
-    workReport: codecWithHash(WorkReport.Codec),
+    workReport: WorkReport.Codec,
     timeout: codec.u32.asOpaque<TimeSlot>(),
   });
 
@@ -9111,7 +9141,7 @@ declare class AvailabilityAssignment extends WithDebug {
 
   private constructor(
     /** Work report assigned to a core. */
-    public readonly workReport: WithHash<WorkReportHash, WorkReport>,
+    public readonly workReport: WorkReport,
     /** Time slot at which the report becomes obsolete. */
     public readonly timeout: TimeSlot,
   ) {
@@ -9161,6 +9191,11 @@ declare class DisputesRecords {
     return new DisputesRecords(goodSet, badSet, wonkySet, punishSet);
   }
 
+  private readonly goodSetDict: ImmutableHashSet<WorkReportHash>;
+  private readonly badSetDict: ImmutableHashSet<WorkReportHash>;
+  private readonly wonkySetDict: ImmutableHashSet<WorkReportHash>;
+  private readonly punishSetDict: ImmutableHashSet<Ed25519Key>;
+
   private constructor(
     /** `goodSet`: all work-reports hashes which were judged to be correct */
     public readonly goodSet: ImmutableSortedSet<WorkReportHash>,
@@ -9170,7 +9205,21 @@ declare class DisputesRecords {
     public readonly wonkySet: ImmutableSortedSet<WorkReportHash>,
     /** `punishSet`: set of Ed25519 keys representing validators which were found to have misjudged a work-report */
     public readonly punishSet: ImmutableSortedSet<Ed25519Key>,
-  ) {}
+  ) {
+    this.goodSetDict = HashSet.from(goodSet.array);
+    this.badSetDict = HashSet.from(badSet.array);
+    this.wonkySetDict = HashSet.from(wonkySet.array);
+    this.punishSetDict = HashSet.from(punishSet.array);
+  }
+
+  public asDictionaries() {
+    return {
+      goodSet: this.goodSetDict,
+      badSet: this.badSetDict,
+      wonkySet: this.wonkySetDict,
+      punishSet: this.punishSetDict,
+    };
+  }
 
   static fromSortedArrays({
     goodSet,
@@ -9196,8 +9245,6 @@ declare function hashComparator<V extends OpaqueHash>(a: V, b: V) {
   return a.compare(b);
 }
 
-// TODO [ToDr] Not sure where these should live yet :(
-
 /**
  * `J`: The maximum sum of dependency items in a work-report.
  *
@@ -9251,56 +9298,274 @@ declare class NotYetAccumulatedReport extends WithDebug {
   }
 }
 
-/** Dictionary entry of services that auto-accumulate every block. */
-declare class AutoAccumulate {
-  static Codec = codec.Class(AutoAccumulate, {
-    service: codec.u32.asOpaque<ServiceId>(),
-    gasLimit: codec.u64.asOpaque<ServiceGas>(),
-  });
-
-  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
-    return new AutoAccumulate(service, gasLimit);
-  }
-
-  private constructor(
-    /** Service id that auto-accumulates. */
-    readonly service: ServiceId,
-    /** Gas limit for auto-accumulation. */
-    readonly gasLimit: ServiceGas,
-  ) {}
-}
-
 /**
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/11da0111da01?v=0.6.7
+ * `B_S`: The basic minimum balance which all services require.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
+ */
+declare const BASE_SERVICE_BALANCE = 100n;
+/**
+ * `B_I`: The additional minimum balance required per item of elective service state.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
  */
-declare class PrivilegedServices {
-  static Codec = codec.Class(PrivilegedServices, {
-    manager: codec.u32.asOpaque<ServiceId>(),
-    authManager: codecPerCore(codec.u32.asOpaque<ServiceId>()),
-    validatorsManager: codec.u32.asOpaque<ServiceId>(),
-    autoAccumulateServices: readonlyArray(codec.sequenceVarLen(AutoAccumulate.Codec)),
-  });
+declare const ELECTIVE_ITEM_BALANCE = 10n;
+/**
+ * `B_L`: The additional minimum balance required per octet of elective service state.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
+ */
+declare const ELECTIVE_BYTE_BALANCE = 1n;
 
-  static create({ manager, authManager, validatorsManager, autoAccumulateServices }: CodecRecord<PrivilegedServices>) {
-    return new PrivilegedServices(manager, authManager, validatorsManager, autoAccumulateServices);
-  }
+declare const zeroSizeHint: SizeHint = {
+  bytes: 0,
+  isExact: true,
+};
 
-  private constructor(
-    /**
-     * `chi_m`: The first, χm, is the index of the manager service which is
-     * the service able to effect an alteration of χ from block to block,
-     * as well as bestow services with storage deposit credits.
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/11a40111a801?v=0.6.7
-     */
-    readonly manager: ServiceId,
-    /** `chi_a`: Manages authorization queue one for each core. */
-    readonly authManager: PerCore<ServiceId>,
-    /** `chi_v`: Managers validator keys. */
-    readonly validatorsManager: ServiceId,
-    /** `chi_g`: Dictionary of services that auto-accumulate every block with their gas limit. */
-    readonly autoAccumulateServices: readonly AutoAccumulate[],
-  ) {}
-}
+/** 0-byte read, return given default value */
+declare const ignoreValueWithDefault = <T>(defaultValue: T) =>
+  Descriptor.new<T>(
+    "ignoreValue",
+    zeroSizeHint,
+    (_e, _v) => {},
+    (_d) => defaultValue,
+    (_s) => {},
+  );
+
+/** Encode and decode object with leading version number. */
+declare const codecWithVersion = <T>(val: Descriptor<T>): Descriptor<T> =>
+  Descriptor.new<T>(
+    "withVersion",
+    {
+      bytes: val.sizeHint.bytes + 8,
+      isExact: false,
+    },
+    (e, v) => {
+      e.varU64(0n);
+      val.encode(e, v);
+    },
+    (d) => {
+      const version = d.varU64();
+      if (version !== 0n) {
+        throw new Error("Non-zero version is not supported!");
+      }
+      return val.decode(d);
+    },
+    (s) => {
+      s.varU64();
+      val.skip(s);
+    },
+  );
+
+/**
+ * Service account details.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
+ */
+declare class ServiceAccountInfo extends WithDebug {
+  static Codec = codec.Class(ServiceAccountInfo, {
+    codeHash: codec.bytes(HASH_SIZE).asOpaque<CodeHash>(),
+    balance: codec.u64,
+    accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+    onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+    storageUtilisationBytes: codec.u64,
+    gratisStorage: codec.u64,
+    storageUtilisationCount: codec.u32,
+    created: codec.u32.convert((x) => x, tryAsTimeSlot),
+    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
+    parentService: codec.u32.convert((x) => x, tryAsServiceId),
+  });
+
+  static create(a: CodecRecord<ServiceAccountInfo>) {
+    return new ServiceAccountInfo(
+      a.codeHash,
+      a.balance,
+      a.accumulateMinGas,
+      a.onTransferMinGas,
+      a.storageUtilisationBytes,
+      a.gratisStorage,
+      a.storageUtilisationCount,
+      a.created,
+      a.lastAccumulation,
+      a.parentService,
+    );
+  }
+
+  /**
+   * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
+   * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
+   */
+  static calculateThresholdBalance(items: U32, bytes: U64, gratisStorage: U64): U64 {
+    const storageCost =
+      BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
+
+    if (storageCost < 0n) {
+      return tryAsU64(0);
+    }
+
+    if (storageCost >= 2n ** 64n) {
+      return tryAsU64(2n ** 64n - 1n);
+    }
+
+    return tryAsU64(storageCost);
+  }
+
+  private constructor(
+    /** `a_c`: Hash of the service code. */
+    public readonly codeHash: CodeHash,
+    /** `a_b`: Current account balance. */
+    public readonly balance: U64,
+    /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
+    public readonly accumulateMinGas: ServiceGas,
+    /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
+    public readonly onTransferMinGas: ServiceGas,
+    /** `a_o`: Total number of octets in storage. */
+    public readonly storageUtilisationBytes: U64,
+    /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
+    public readonly gratisStorage: U64,
+    /** `a_i`: Number of items in storage. */
+    public readonly storageUtilisationCount: U32,
+    /** `a_r`: Creation account time slot. */
+    public readonly created: TimeSlot,
+    /** `a_a`: Most recent accumulation time slot. */
+    public readonly lastAccumulation: TimeSlot,
+    /** `a_p`: Parent service ID. */
+    public readonly parentService: ServiceId,
+  ) {
+    super();
+  }
+}
+
+declare class PreimageItem extends WithDebug {
+  static Codec = codec.Class(PreimageItem, {
+    hash: codec.bytes(HASH_SIZE).asOpaque<PreimageHash>(),
+    blob: codec.blob,
+  });
+
+  static create({ hash, blob }: CodecRecord<PreimageItem>) {
+    return new PreimageItem(hash, blob);
+  }
+
+  private constructor(
+    readonly hash: PreimageHash,
+    readonly blob: BytesBlob,
+  ) {
+    super();
+  }
+}
+
+type StorageKey = Opaque<BytesBlob, "storage key">;
+
+declare class StorageItem extends WithDebug {
+  static Codec = codec.Class(StorageItem, {
+    key: codec.blob.convert(
+      (i) => i,
+      (o) => asOpaqueType(o),
+    ),
+    value: codec.blob,
+  });
+
+  static create({ key, value }: CodecRecord<StorageItem>) {
+    return new StorageItem(key, value);
+  }
+
+  private constructor(
+    readonly key: StorageKey,
+    readonly value: BytesBlob,
+  ) {
+    super();
+  }
+}
+
+declare const MAX_LOOKUP_HISTORY_SLOTS = 3;
+type LookupHistorySlots = KnownSizeArray<TimeSlot, `0-${typeof MAX_LOOKUP_HISTORY_SLOTS} timeslots`>;
+declare function tryAsLookupHistorySlots(items: readonly TimeSlot[]): LookupHistorySlots {
+  const knownSize = asKnownSize(items) as LookupHistorySlots;
+  if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
+    throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
+  }
+  return knownSize;
+}
+
+/** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
+declare class LookupHistoryItem {
+  constructor(
+    public readonly hash: PreimageHash,
+    public readonly length: U32,
+    /**
+     * Preimage availability history as a sequence of time slots.
+     * See PreimageStatus and the following GP fragment for more details.
+     * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
+    public readonly slots: LookupHistorySlots,
+  ) {}
+
+  static isRequested(item: LookupHistoryItem | LookupHistorySlots): boolean {
+    if ("slots" in item) {
+      return item.slots.length === 0;
+    }
+    return item.length === 0;
+  }
+}
+
+/** Dictionary entry of services that auto-accumulate every block. */
+declare class AutoAccumulate {
+  static Codec = codec.Class(AutoAccumulate, {
+    service: codec.u32.asOpaque<ServiceId>(),
+    gasLimit: codec.u64.asOpaque<ServiceGas>(),
+  });
+
+  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
+    return new AutoAccumulate(service, gasLimit);
+  }
+
+  private constructor(
+    /** Service id that auto-accumulates. */
+    readonly service: ServiceId,
+    /** Gas limit for auto-accumulation. */
+    readonly gasLimit: ServiceGas,
+  ) {}
+}
+
+/**
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
+ */
+declare class PrivilegedServices {
+  /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
+  static Codec = codec.Class(PrivilegedServices, {
+    manager: codec.u32.asOpaque<ServiceId>(),
+    assigners: codecPerCore(codec.u32.asOpaque<ServiceId>()),
+    delegator: codec.u32.asOpaque<ServiceId>(),
+    registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+      ? codec.u32.asOpaque<ServiceId>()
+      : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
+    autoAccumulateServices: readonlyArray(codec.sequenceVarLen(AutoAccumulate.Codec)),
+  });
+
+  static create(a: CodecRecord<PrivilegedServices>) {
+    return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
+  }
+
+  private constructor(
+    /**
+     * `χ_M`: Manages alteration of χ from block to block,
+     * as well as bestow services with storage deposit credits.
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
+     */
+    readonly manager: ServiceId,
+    /** `χ_V`: Managers validator keys. */
+    readonly delegator: ServiceId,
+    /**
+     * `χ_R`: Manages the creation of services in protected range.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
+     */
+    readonly registrar: ServiceId,
+    /** `χ_A`: Manages authorization queue one for each core. */
+    readonly assigners: PerCore<ServiceId>,
+    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
+    readonly autoAccumulateServices: readonly AutoAccumulate[],
+  ) {}
+}
 
 declare const SUPER_PEAK_STRING = BytesBlob.blobFromString("peak");
 
@@ -9448,16 +9713,16 @@ declare class Mountain<H extends OpaqueHash> {
   }
 }
 
-type index$d_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$d_MerkleMountainRange: typeof MerkleMountainRange;
-type index$d_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$d_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-type index$d_Mountain<H extends OpaqueHash> = Mountain<H>;
-declare const index$d_Mountain: typeof Mountain;
-declare const index$d_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
-declare namespace index$d {
-  export { index$d_MerkleMountainRange as MerkleMountainRange, index$d_Mountain as Mountain, index$d_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
-  export type { index$d_MmrHasher as MmrHasher, index$d_MmrPeaks as MmrPeaks };
+type index$f_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const index$f_MerkleMountainRange: typeof MerkleMountainRange;
+type index$f_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type index$f_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+type index$f_Mountain<H extends OpaqueHash> = Mountain<H>;
+declare const index$f_Mountain: typeof Mountain;
+declare const index$f_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
+declare namespace index$f {
+  export { index$f_MerkleMountainRange as MerkleMountainRange, index$f_Mountain as Mountain, index$f_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
+  export type { index$f_MmrHasher as MmrHasher, index$f_MmrPeaks as MmrPeaks };
 }
 
 /**
@@ -9728,206 +9993,22 @@ declare class SafroleData {
     epochRoot: codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque<BandersnatchRingRoot>(),
     sealingKeySeries: SafroleSealingKeysData.Codec,
     ticketsAccumulator: readonlyArray(codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
-  });
-
-  static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }: CodecRecord<SafroleData>) {
-    return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
-  }
-
-  private constructor(
-    /** gamma_k */
-    public readonly nextValidatorData: PerValidator<ValidatorData>,
-    /** gamma_z */
-    public readonly epochRoot: BandersnatchRingRoot,
-    /** gamma_s */
-    public readonly sealingKeySeries: SafroleSealingKeys,
-    /** gamma_a */
-    public readonly ticketsAccumulator: KnownSizeArray<Ticket, "0...EpochLength">,
-  ) {}
-}
-
-/**
- * `B_S`: The basic minimum balance which all services require.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
- */
-declare const BASE_SERVICE_BALANCE = 100n;
-/**
- * `B_I`: The additional minimum balance required per item of elective service state.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
- */
-declare const ELECTIVE_ITEM_BALANCE = 10n;
-/**
- * `B_L`: The additional minimum balance required per octet of elective service state.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
- */
-declare const ELECTIVE_BYTE_BALANCE = 1n;
-
-declare const zeroSizeHint: SizeHint = {
-  bytes: 0,
-  isExact: true,
-};
-
-/** 0-byte read, return given default value */
-declare const ignoreValueWithDefault = <T>(defaultValue: T) =>
-  Descriptor.new<T>(
-    "ignoreValue",
-    zeroSizeHint,
-    (_e, _v) => {},
-    (_d) => defaultValue,
-    (_s) => {},
-  );
-
-/**
- * Service account details.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
- */
-declare class ServiceAccountInfo extends WithDebug {
-  static Codec = codec.Class(ServiceAccountInfo, {
-    codeHash: codec.bytes(HASH_SIZE).asOpaque<CodeHash>(),
-    balance: codec.u64,
-    accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-    onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-    storageUtilisationBytes: codec.u64,
-    gratisStorage: codec.u64,
-    storageUtilisationCount: codec.u32,
-    created: codec.u32.convert((x) => x, tryAsTimeSlot),
-    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
-    parentService: codec.u32.convert((x) => x, tryAsServiceId),
-  });
-
-  static create(a: CodecRecord<ServiceAccountInfo>) {
-    return new ServiceAccountInfo(
-      a.codeHash,
-      a.balance,
-      a.accumulateMinGas,
-      a.onTransferMinGas,
-      a.storageUtilisationBytes,
-      a.gratisStorage,
-      a.storageUtilisationCount,
-      a.created,
-      a.lastAccumulation,
-      a.parentService,
-    );
-  }
-
-  /**
-   * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
-   * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
-   */
-  static calculateThresholdBalance(items: U32, bytes: U64, gratisStorage: U64): U64 {
-    const storageCost =
-      BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
-
-    if (storageCost < 0n) {
-      return tryAsU64(0);
-    }
-
-    if (storageCost >= 2n ** 64n) {
-      return tryAsU64(2n ** 64n - 1n);
-    }
-
-    return tryAsU64(storageCost);
-  }
-
-  private constructor(
-    /** `a_c`: Hash of the service code. */
-    public readonly codeHash: CodeHash,
-    /** `a_b`: Current account balance. */
-    public readonly balance: U64,
-    /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
-    public readonly accumulateMinGas: ServiceGas,
-    /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
-    public readonly onTransferMinGas: ServiceGas,
-    /** `a_o`: Total number of octets in storage. */
-    public readonly storageUtilisationBytes: U64,
-    /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
-    public readonly gratisStorage: U64,
-    /** `a_i`: Number of items in storage. */
-    public readonly storageUtilisationCount: U32,
-    /** `a_r`: Creation account time slot. */
-    public readonly created: TimeSlot,
-    /** `a_a`: Most recent accumulation time slot. */
-    public readonly lastAccumulation: TimeSlot,
-    /** `a_p`: Parent service ID. */
-    public readonly parentService: ServiceId,
-  ) {
-    super();
-  }
-}
-
-declare class PreimageItem extends WithDebug {
-  static Codec = codec.Class(PreimageItem, {
-    hash: codec.bytes(HASH_SIZE).asOpaque<PreimageHash>(),
-    blob: codec.blob,
-  });
-
-  static create({ hash, blob }: CodecRecord<PreimageItem>) {
-    return new PreimageItem(hash, blob);
-  }
-
-  private constructor(
-    readonly hash: PreimageHash,
-    readonly blob: BytesBlob,
-  ) {
-    super();
-  }
-}
-
-type StorageKey = Opaque<BytesBlob, "storage key">;
-
-declare class StorageItem extends WithDebug {
-  static Codec = codec.Class(StorageItem, {
-    key: codec.blob.convert(
-      (i) => i,
-      (o) => asOpaqueType(o),
-    ),
-    value: codec.blob,
-  });
-
-  static create({ key, value }: CodecRecord<StorageItem>) {
-    return new StorageItem(key, value);
-  }
-
-  private constructor(
-    readonly key: StorageKey,
-    readonly value: BytesBlob,
-  ) {
-    super();
-  }
-}
-
-declare const MAX_LOOKUP_HISTORY_SLOTS = 3;
-type LookupHistorySlots = KnownSizeArray<TimeSlot, `0-${typeof MAX_LOOKUP_HISTORY_SLOTS} timeslots`>;
-declare function tryAsLookupHistorySlots(items: readonly TimeSlot[]): LookupHistorySlots {
-  const knownSize = asKnownSize(items) as LookupHistorySlots;
-  if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
-    throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
-  }
-  return knownSize;
-}
-
-/** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
-declare class LookupHistoryItem {
-  constructor(
-    public readonly hash: PreimageHash,
-    public readonly length: U32,
-    /**
-     * Preimage availability history as a sequence of time slots.
-     * See PreimageStatus and the following GP fragment for more details.
-     * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
-    public readonly slots: LookupHistorySlots,
-  ) {}
+  });
 
-  static isRequested(item: LookupHistoryItem | LookupHistorySlots): boolean {
-    if ("slots" in item) {
-      return item.slots.length === 0;
-    }
-    return item.length === 0;
+  static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }: CodecRecord<SafroleData>) {
+    return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
   }
+
+  private constructor(
+    /** gamma_k */
+    public readonly nextValidatorData: PerValidator<ValidatorData>,
+    /** gamma_z */
+    public readonly epochRoot: BandersnatchRingRoot,
+    /** gamma_s */
+    public readonly sealingKeySeries: SafroleSealingKeys,
+    /** gamma_a */
+    public readonly ticketsAccumulator: KnownSizeArray<Ticket, "0...EpochLength">,
+  ) {}
 }
 
 declare const codecServiceId: Descriptor<ServiceId> =
@@ -11104,8 +11185,9 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
       epochRoot: Bytes.zero(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
       privilegedServices: PrivilegedServices.create({
         manager: tryAsServiceId(0),
-        authManager: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
-        validatorsManager: tryAsServiceId(0),
+        assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
+        delegator: tryAsServiceId(0),
+        registrar: tryAsServiceId(MAX_VALUE),
         autoAccumulateServices: [],
       }),
       accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
@@ -11155,103 +11237,103 @@ type FieldNames<T> = {
   [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-type index$c_AccumulationOutput = AccumulationOutput;
-declare const index$c_AccumulationOutput: typeof AccumulationOutput;
-type index$c_AutoAccumulate = AutoAccumulate;
-declare const index$c_AutoAccumulate: typeof AutoAccumulate;
-type index$c_AvailabilityAssignment = AvailabilityAssignment;
-declare const index$c_AvailabilityAssignment: typeof AvailabilityAssignment;
-declare const index$c_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
-type index$c_BlockState = BlockState;
-declare const index$c_BlockState: typeof BlockState;
-type index$c_BlocksState = BlocksState;
-type index$c_CoreStatistics = CoreStatistics;
-declare const index$c_CoreStatistics: typeof CoreStatistics;
-type index$c_DisputesRecords = DisputesRecords;
-declare const index$c_DisputesRecords: typeof DisputesRecords;
-declare const index$c_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
-declare const index$c_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
-type index$c_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
-type index$c_EnumerableState = EnumerableState;
-type index$c_FieldNames<T> = FieldNames<T>;
-type index$c_InMemoryService = InMemoryService;
-declare const index$c_InMemoryService: typeof InMemoryService;
-type index$c_InMemoryState = InMemoryState;
-declare const index$c_InMemoryState: typeof InMemoryState;
-type index$c_InMemoryStateFields = InMemoryStateFields;
-type index$c_LookupHistoryItem = LookupHistoryItem;
-declare const index$c_LookupHistoryItem: typeof LookupHistoryItem;
-type index$c_LookupHistorySlots = LookupHistorySlots;
-declare const index$c_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
-type index$c_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
-type index$c_PerCore<T> = PerCore<T>;
-type index$c_PreimageItem = PreimageItem;
-declare const index$c_PreimageItem: typeof PreimageItem;
-type index$c_PrivilegedServices = PrivilegedServices;
-declare const index$c_PrivilegedServices: typeof PrivilegedServices;
-type index$c_RecentBlocks = RecentBlocks;
-declare const index$c_RecentBlocks: typeof RecentBlocks;
-type index$c_RecentBlocksHistory = RecentBlocksHistory;
-declare const index$c_RecentBlocksHistory: typeof RecentBlocksHistory;
-type index$c_SafroleData = SafroleData;
-declare const index$c_SafroleData: typeof SafroleData;
-type index$c_SafroleSealingKeys = SafroleSealingKeys;
-type index$c_SafroleSealingKeysData = SafroleSealingKeysData;
-declare const index$c_SafroleSealingKeysData: typeof SafroleSealingKeysData;
-type index$c_SafroleSealingKeysKind = SafroleSealingKeysKind;
-declare const index$c_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
-type index$c_Service = Service;
-type index$c_ServiceAccountInfo = ServiceAccountInfo;
-declare const index$c_ServiceAccountInfo: typeof ServiceAccountInfo;
-type index$c_ServiceData = ServiceData;
-type index$c_ServiceEntries = ServiceEntries;
-type index$c_ServiceStatistics = ServiceStatistics;
-declare const index$c_ServiceStatistics: typeof ServiceStatistics;
-type index$c_ServicesUpdate = ServicesUpdate;
-type index$c_State = State;
-type index$c_StatisticsData = StatisticsData;
-declare const index$c_StatisticsData: typeof StatisticsData;
-type index$c_StorageItem = StorageItem;
-declare const index$c_StorageItem: typeof StorageItem;
-type index$c_StorageKey = StorageKey;
-type index$c_UpdateError = UpdateError;
-declare const index$c_UpdateError: typeof UpdateError;
-type index$c_UpdatePreimage = UpdatePreimage;
-declare const index$c_UpdatePreimage: typeof UpdatePreimage;
-type index$c_UpdatePreimageKind = UpdatePreimageKind;
-declare const index$c_UpdatePreimageKind: typeof UpdatePreimageKind;
-type index$c_UpdateService = UpdateService;
-declare const index$c_UpdateService: typeof UpdateService;
-type index$c_UpdateServiceKind = UpdateServiceKind;
-declare const index$c_UpdateServiceKind: typeof UpdateServiceKind;
-type index$c_UpdateStorage = UpdateStorage;
-declare const index$c_UpdateStorage: typeof UpdateStorage;
-type index$c_UpdateStorageKind = UpdateStorageKind;
-declare const index$c_UpdateStorageKind: typeof UpdateStorageKind;
-type index$c_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
-type index$c_ValidatorData = ValidatorData;
-declare const index$c_ValidatorData: typeof ValidatorData;
-type index$c_ValidatorStatistics = ValidatorStatistics;
-declare const index$c_ValidatorStatistics: typeof ValidatorStatistics;
-declare const index$c_accumulationOutputComparator: typeof accumulationOutputComparator;
-declare const index$c_codecBandersnatchKey: typeof codecBandersnatchKey;
-declare const index$c_codecPerCore: typeof codecPerCore;
-declare const index$c_codecServiceId: typeof codecServiceId;
-declare const index$c_codecVarGas: typeof codecVarGas;
-declare const index$c_codecVarU16: typeof codecVarU16;
-declare const index$c_codecWithHash: typeof codecWithHash;
-declare const index$c_hashComparator: typeof hashComparator;
-declare const index$c_ignoreValueWithDefault: typeof ignoreValueWithDefault;
-declare const index$c_serviceDataCodec: typeof serviceDataCodec;
-declare const index$c_serviceEntriesCodec: typeof serviceEntriesCodec;
-declare const index$c_sortedSetCodec: typeof sortedSetCodec;
-declare const index$c_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
-declare const index$c_tryAsPerCore: typeof tryAsPerCore;
-declare const index$c_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
-declare const index$c_zeroSizeHint: typeof zeroSizeHint;
-declare namespace index$c {
-  export { index$c_AccumulationOutput as AccumulationOutput, index$c_AutoAccumulate as AutoAccumulate, index$c_AvailabilityAssignment as AvailabilityAssignment, index$c_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$c_BlockState as BlockState, index$c_CoreStatistics as CoreStatistics, index$c_DisputesRecords as DisputesRecords, index$c_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$c_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$c_InMemoryService as InMemoryService, index$c_InMemoryState as InMemoryState, index$c_LookupHistoryItem as LookupHistoryItem, index$c_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$c_PreimageItem as PreimageItem, index$c_PrivilegedServices as PrivilegedServices, index$c_RecentBlocks as RecentBlocks, index$c_RecentBlocksHistory as RecentBlocksHistory, index$c_SafroleData as SafroleData, index$c_SafroleSealingKeysData as SafroleSealingKeysData, index$c_SafroleSealingKeysKind as SafroleSealingKeysKind, index$c_ServiceAccountInfo as ServiceAccountInfo, index$c_ServiceStatistics as ServiceStatistics, index$c_StatisticsData as StatisticsData, index$c_StorageItem as StorageItem, index$c_UpdateError as UpdateError, index$c_UpdatePreimage as UpdatePreimage, index$c_UpdatePreimageKind as UpdatePreimageKind, index$c_UpdateService as UpdateService, index$c_UpdateServiceKind as UpdateServiceKind, index$c_UpdateStorage as UpdateStorage, index$c_UpdateStorageKind as UpdateStorageKind, index$c_ValidatorData as ValidatorData, index$c_ValidatorStatistics as ValidatorStatistics, index$c_accumulationOutputComparator as accumulationOutputComparator, index$c_codecBandersnatchKey as codecBandersnatchKey, index$c_codecPerCore as codecPerCore, index$c_codecServiceId as codecServiceId, index$c_codecVarGas as codecVarGas, index$c_codecVarU16 as codecVarU16, index$c_codecWithHash as codecWithHash, index$c_hashComparator as hashComparator, index$c_ignoreValueWithDefault as ignoreValueWithDefault, index$c_serviceDataCodec as serviceDataCodec, index$c_serviceEntriesCodec as serviceEntriesCodec, index$c_sortedSetCodec as sortedSetCodec, index$c_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$c_tryAsPerCore as tryAsPerCore, index$c_workReportsSortedSetCodec as workReportsSortedSetCodec, index$c_zeroSizeHint as zeroSizeHint };
-  export type { index$c_BlocksState as BlocksState, index$c_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$c_EnumerableState as EnumerableState, index$c_FieldNames as FieldNames, index$c_InMemoryStateFields as InMemoryStateFields, index$c_LookupHistorySlots as LookupHistorySlots, index$c_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$c_PerCore as PerCore, index$c_SafroleSealingKeys as SafroleSealingKeys, index$c_Service as Service, index$c_ServiceData as ServiceData, index$c_ServiceEntries as ServiceEntries, index$c_ServicesUpdate as ServicesUpdate, index$c_State as State, index$c_StorageKey as StorageKey, index$c_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
+type index$e_AccumulationOutput = AccumulationOutput;
+declare const index$e_AccumulationOutput: typeof AccumulationOutput;
+type index$e_AutoAccumulate = AutoAccumulate;
+declare const index$e_AutoAccumulate: typeof AutoAccumulate;
+type index$e_AvailabilityAssignment = AvailabilityAssignment;
+declare const index$e_AvailabilityAssignment: typeof AvailabilityAssignment;
+declare const index$e_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
+type index$e_BlockState = BlockState;
+declare const index$e_BlockState: typeof BlockState;
+type index$e_BlocksState = BlocksState;
+type index$e_CoreStatistics = CoreStatistics;
+declare const index$e_CoreStatistics: typeof CoreStatistics;
+type index$e_DisputesRecords = DisputesRecords;
+declare const index$e_DisputesRecords: typeof DisputesRecords;
+declare const index$e_ELECTIVE_BYTE_BALANCE: typeof ELECTIVE_BYTE_BALANCE;
+declare const index$e_ELECTIVE_ITEM_BALANCE: typeof ELECTIVE_ITEM_BALANCE;
+type index$e_ENTROPY_ENTRIES = ENTROPY_ENTRIES;
+type index$e_EnumerableState = EnumerableState;
+type index$e_FieldNames<T> = FieldNames<T>;
+type index$e_InMemoryService = InMemoryService;
+declare const index$e_InMemoryService: typeof InMemoryService;
+type index$e_InMemoryState = InMemoryState;
+declare const index$e_InMemoryState: typeof InMemoryState;
+type index$e_InMemoryStateFields = InMemoryStateFields;
+type index$e_LookupHistoryItem = LookupHistoryItem;
+declare const index$e_LookupHistoryItem: typeof LookupHistoryItem;
+type index$e_LookupHistorySlots = LookupHistorySlots;
+declare const index$e_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
+type index$e_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
+type index$e_PerCore<T> = PerCore<T>;
+type index$e_PreimageItem = PreimageItem;
+declare const index$e_PreimageItem: typeof PreimageItem;
+type index$e_PrivilegedServices = PrivilegedServices;
+declare const index$e_PrivilegedServices: typeof PrivilegedServices;
+type index$e_RecentBlocks = RecentBlocks;
+declare const index$e_RecentBlocks: typeof RecentBlocks;
+type index$e_RecentBlocksHistory = RecentBlocksHistory;
+declare const index$e_RecentBlocksHistory: typeof RecentBlocksHistory;
+type index$e_SafroleData = SafroleData;
+declare const index$e_SafroleData: typeof SafroleData;
+type index$e_SafroleSealingKeys = SafroleSealingKeys;
+type index$e_SafroleSealingKeysData = SafroleSealingKeysData;
+declare const index$e_SafroleSealingKeysData: typeof SafroleSealingKeysData;
+type index$e_SafroleSealingKeysKind = SafroleSealingKeysKind;
+declare const index$e_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
+type index$e_Service = Service;
+type index$e_ServiceAccountInfo = ServiceAccountInfo;
+declare const index$e_ServiceAccountInfo: typeof ServiceAccountInfo;
+type index$e_ServiceData = ServiceData;
+type index$e_ServiceEntries = ServiceEntries;
+type index$e_ServiceStatistics = ServiceStatistics;
+declare const index$e_ServiceStatistics: typeof ServiceStatistics;
+type index$e_ServicesUpdate = ServicesUpdate;
+type index$e_State = State;
+type index$e_StatisticsData = StatisticsData;
+declare const index$e_StatisticsData: typeof StatisticsData;
+type index$e_StorageItem = StorageItem;
+declare const index$e_StorageItem: typeof StorageItem;
+type index$e_StorageKey = StorageKey;
+type index$e_UpdateError = UpdateError;
+declare const index$e_UpdateError: typeof UpdateError;
+type index$e_UpdatePreimage = UpdatePreimage;
+declare const index$e_UpdatePreimage: typeof UpdatePreimage;
+type index$e_UpdatePreimageKind = UpdatePreimageKind;
+declare const index$e_UpdatePreimageKind: typeof UpdatePreimageKind;
+type index$e_UpdateService = UpdateService;
+declare const index$e_UpdateService: typeof UpdateService;
+type index$e_UpdateServiceKind = UpdateServiceKind;
+declare const index$e_UpdateServiceKind: typeof UpdateServiceKind;
+type index$e_UpdateStorage = UpdateStorage;
+declare const index$e_UpdateStorage: typeof UpdateStorage;
+type index$e_UpdateStorageKind = UpdateStorageKind;
+declare const index$e_UpdateStorageKind: typeof UpdateStorageKind;
+type index$e_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
+type index$e_ValidatorData = ValidatorData;
+declare const index$e_ValidatorData: typeof ValidatorData;
+type index$e_ValidatorStatistics = ValidatorStatistics;
+declare const index$e_ValidatorStatistics: typeof ValidatorStatistics;
+declare const index$e_accumulationOutputComparator: typeof accumulationOutputComparator;
+declare const index$e_codecBandersnatchKey: typeof codecBandersnatchKey;
+declare const index$e_codecPerCore: typeof codecPerCore;
+declare const index$e_codecServiceId: typeof codecServiceId;
+declare const index$e_codecVarGas: typeof codecVarGas;
+declare const index$e_codecVarU16: typeof codecVarU16;
+declare const index$e_codecWithVersion: typeof codecWithVersion;
+declare const index$e_hashComparator: typeof hashComparator;
+declare const index$e_ignoreValueWithDefault: typeof ignoreValueWithDefault;
+declare const index$e_serviceDataCodec: typeof serviceDataCodec;
+declare const index$e_serviceEntriesCodec: typeof serviceEntriesCodec;
+declare const index$e_sortedSetCodec: typeof sortedSetCodec;
+declare const index$e_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
+declare const index$e_tryAsPerCore: typeof tryAsPerCore;
+declare const index$e_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
+declare const index$e_zeroSizeHint: typeof zeroSizeHint;
+declare namespace index$e {
+  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_RecentBlocksHistory as RecentBlocksHistory, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithVersion as codecWithVersion, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export type { index$e_BlocksState as BlocksState, index$e_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$e_EnumerableState as EnumerableState, index$e_FieldNames as FieldNames, index$e_InMemoryStateFields as InMemoryStateFields, index$e_LookupHistorySlots as LookupHistorySlots, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -11318,7 +11400,7 @@ declare namespace stateKeys {
   }
 
   /** https://graypaper.fluffylabs.dev/#/1c979cb/3bba033bba03?v=0.7.1 */
-  export function serviceStorage(serviceId: ServiceId, key: StorageKey): StateKey {
+  export function serviceStorage(blake2b: Blake2b, serviceId: ServiceId, key: StorageKey): StateKey {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const out = Bytes.zero(HASH_SIZE);
       out.raw.set(u32AsLeBytes(tryAsU32(2 ** 32 - 1)), 0);
@@ -11326,11 +11408,11 @@ declare namespace stateKeys {
       return legacyServiceNested(serviceId, out);
     }
 
-    return serviceNested(serviceId, tryAsU32(2 ** 32 - 1), key);
+    return serviceNested(blake2b, serviceId, tryAsU32(2 ** 32 - 1), key);
   }
 
   /** https://graypaper.fluffylabs.dev/#/1c979cb/3bd7033bd703?v=0.7.1 */
-  export function servicePreimage(serviceId: ServiceId, hash: PreimageHash): StateKey {
+  export function servicePreimage(blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash): StateKey {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const out = Bytes.zero(HASH_SIZE);
       out.raw.set(u32AsLeBytes(tryAsU32(2 ** 32 - 2)), 0);
@@ -11338,11 +11420,16 @@ declare namespace stateKeys {
       return legacyServiceNested(serviceId, out);
     }
 
-    return serviceNested(serviceId, tryAsU32(2 ** 32 - 2), hash);
+    return serviceNested(blake2b, serviceId, tryAsU32(2 ** 32 - 2), hash);
   }
 
   /** https://graypaper.fluffylabs.dev/#/1c979cb/3b0a043b0a04?v=0.7.1 */
-  export function serviceLookupHistory(serviceId: ServiceId, hash: PreimageHash, preimageLength: U32): StateKey {
+  export function serviceLookupHistory(
+    blake2b: Blake2b,
+    serviceId: ServiceId,
+    hash: PreimageHash,
+    preimageLength: U32,
+  ): StateKey {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const doubleHash = blake2b.hashBytes(hash);
       const out = Bytes.zero(HASH_SIZE);
@@ -11351,11 +11438,11 @@ declare namespace stateKeys {
       return legacyServiceNested(serviceId, out);
     }
 
-    return serviceNested(serviceId, preimageLength, hash);
+    return serviceNested(blake2b, serviceId, preimageLength, hash);
   }
 
   /** https://graypaper.fluffylabs.dev/#/1c979cb/3b88003b8800?v=0.7.1 */
-  export function serviceNested(serviceId: ServiceId, numberPrefix: U32, hash: BytesBlob): StateKey {
+  export function serviceNested(blake2b: Blake2b, serviceId: ServiceId, numberPrefix: U32, hash: BytesBlob): StateKey {
     const inputToHash = BytesBlob.blobFromParts(u32AsLeBytes(numberPrefix), hash.raw);
     const newHash = blake2b.hashBytes(inputToHash).raw.subarray(0, 28);
     const key = Bytes.zero(HASH_SIZE);
@@ -11535,24 +11622,26 @@ declare namespace serialize {
   /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
   export const serviceData = (serviceId: ServiceId) => ({
     key: stateKeys.serviceInfo(serviceId),
-    Codec: ServiceAccountInfo.Codec,
+    Codec: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+      ? codecWithVersion(ServiceAccountInfo.Codec)
+      : ServiceAccountInfo.Codec,
   });
 
   /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
-  export const serviceStorage = (serviceId: ServiceId, key: StorageKey) => ({
-    key: stateKeys.serviceStorage(serviceId, key),
+  export const serviceStorage = (blake2b: Blake2b, serviceId: ServiceId, key: StorageKey) => ({
+    key: stateKeys.serviceStorage(blake2b, serviceId, key),
     Codec: dumpCodec,
   });
 
   /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
-  export const servicePreimages = (serviceId: ServiceId, hash: PreimageHash) => ({
-    key: stateKeys.servicePreimage(serviceId, hash),
+  export const servicePreimages = (blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash) => ({
+    key: stateKeys.servicePreimage(blake2b, serviceId, hash),
     Codec: dumpCodec,
   });
 
   /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
-  export const serviceLookupHistory = (serviceId: ServiceId, hash: PreimageHash, len: U32) => ({
-    key: stateKeys.serviceLookupHistory(serviceId, hash, len),
+  export const serviceLookupHistory = (blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash, len: U32) => ({
+    key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
     Codec: readonlyArray(codec.sequenceVarLen(codec.u32)),
   });
 }
@@ -11587,6 +11676,7 @@ declare const EMPTY_BLOB = BytesBlob.empty();
 /** Serialize given state update into a series of key-value pairs. */
 declare function* serializeStateUpdate(
   spec: ChainSpec,
+  blake2b: Blake2b,
   update: Partial<State & ServicesUpdate>,
 ): Generator<StateEntryUpdate> {
   // first let's serialize all of the simple entries (if present!)
@@ -11595,9 +11685,9 @@ declare function* serializeStateUpdate(
   const encode = <T>(codec: Encode<T>, val: T) => Encoder.encodeObject(codec, val, spec);
 
   // then let's proceed with service updates
-  yield* serializeServiceUpdates(update.servicesUpdates, encode);
-  yield* serializePreimages(update.preimages, encode);
-  yield* serializeStorage(update.storage);
+  yield* serializeServiceUpdates(update.servicesUpdates, encode, blake2b);
+  yield* serializePreimages(update.preimages, encode, blake2b);
+  yield* serializeStorage(update.storage, blake2b);
   yield* serializeRemovedServices(update.servicesRemoved);
 }
 
@@ -11609,18 +11699,18 @@ declare function* serializeRemovedServices(servicesRemoved: ServiceId[] | undefi
   }
 }
 
-declare function* serializeStorage(storage: UpdateStorage[] | undefined): Generator<StateEntryUpdate> {
+declare function* serializeStorage(storage: UpdateStorage[] | undefined, blake2b: Blake2b): Generator<StateEntryUpdate> {
   for (const { action, serviceId } of storage ?? []) {
     switch (action.kind) {
       case UpdateStorageKind.Set: {
         const key = action.storage.key;
-        const codec = serialize.serviceStorage(serviceId, key);
+        const codec = serialize.serviceStorage(blake2b, serviceId, key);
         yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
         break;
       }
       case UpdateStorageKind.Remove: {
         const key = action.key;
-        const codec = serialize.serviceStorage(serviceId, key);
+        const codec = serialize.serviceStorage(blake2b, serviceId, key);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
         break;
       }
@@ -11630,16 +11720,20 @@ declare function* serializeStorage(storage: UpdateStorage[] | undefined): Genera
   }
 }
 
-declare function* serializePreimages(preimages: UpdatePreimage[] | undefined, encode: EncodeFun): Generator<StateEntryUpdate> {
+declare function* serializePreimages(
+  preimages: UpdatePreimage[] | undefined,
+  encode: EncodeFun,
+  blake2b: Blake2b,
+): Generator<StateEntryUpdate> {
   for (const { action, serviceId } of preimages ?? []) {
     switch (action.kind) {
       case UpdatePreimageKind.Provide: {
         const { hash, blob } = action.preimage;
-        const codec = serialize.servicePreimages(serviceId, hash);
+        const codec = serialize.servicePreimages(blake2b, serviceId, hash);
         yield [StateEntryUpdateAction.Insert, codec.key, blob];
 
         if (action.slot !== null) {
-          const codec2 = serialize.serviceLookupHistory(serviceId, hash, tryAsU32(blob.length));
+          const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
           yield [
             StateEntryUpdateAction.Insert,
             codec2.key,
@@ -11650,16 +11744,16 @@ declare function* serializePreimages(preimages: UpdatePreimage[] | undefined, en
       }
       case UpdatePreimageKind.UpdateOrAdd: {
         const { hash, length, slots } = action.item;
-        const codec = serialize.serviceLookupHistory(serviceId, hash, length);
+        const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
         yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
         break;
       }
       case UpdatePreimageKind.Remove: {
         const { hash, length } = action;
-        const codec = serialize.servicePreimages(serviceId, hash);
+        const codec = serialize.servicePreimages(blake2b, serviceId, hash);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
 
-        const codec2 = serialize.serviceLookupHistory(serviceId, hash, length);
+        const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
         yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
         break;
       }
@@ -11671,6 +11765,7 @@ declare function* serializePreimages(preimages: UpdatePreimage[] | undefined, en
 declare function* serializeServiceUpdates(
   servicesUpdates: UpdateService[] | undefined,
   encode: EncodeFun,
+  blake2b: Blake2b,
 ): Generator<StateEntryUpdate> {
   for (const { action, serviceId } of servicesUpdates ?? []) {
     // new service being created or updated
@@ -11680,7 +11775,7 @@ declare function* serializeServiceUpdates(
     // additional lookup history update
     if (action.kind === UpdateServiceKind.Create && action.lookupHistory !== null) {
       const { lookupHistory } = action;
-      const codec2 = serialize.serviceLookupHistory(serviceId, lookupHistory.hash, lookupHistory.length);
+      const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
       yield [StateEntryUpdateAction.Insert, codec2.key, encode(codec2.Codec, lookupHistory.slots)];
     }
   }
@@ -11814,8 +11909,8 @@ declare class StateEntries {
   );
 
   /** Turn in-memory state into it's serialized form. */
-  static serializeInMemory(spec: ChainSpec, state: InMemoryState) {
-    return new StateEntries(convertInMemoryStateToDictionary(spec, state));
+  static serializeInMemory(spec: ChainSpec, blake2b: Blake2b, state: InMemoryState) {
+    return new StateEntries(convertInMemoryStateToDictionary(spec, blake2b, state));
   }
 
   /**
@@ -11870,7 +11965,8 @@ declare class StateEntries {
   }
 
   /** https://graypaper.fluffylabs.dev/#/68eaa1f/391600391600?v=0.6.4 */
-  getRootHash(): StateRootHash {
+  getRootHash(blake2b: Blake2b): StateRootHash {
+    const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
     const leaves: SortedSet<LeafNode> = SortedSet.fromArray(leafComparator);
     for (const [key, value] of this) {
       leaves.insert(InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value));
@@ -11883,6 +11979,7 @@ declare class StateEntries {
 /** https://graypaper.fluffylabs.dev/#/68eaa1f/38a50038a500?v=0.6.4 */
 declare function convertInMemoryStateToDictionary(
   spec: ChainSpec,
+  blake2b: Blake2b,
   state: InMemoryState,
 ): TruncatedHashDictionary<StateKey, BytesBlob> {
   const serialized = TruncatedHashDictionary.fromEntries<StateKey, BytesBlob>([]);
@@ -11915,20 +12012,25 @@ declare function convertInMemoryStateToDictionary(
 
     // preimages
     for (const preimage of service.data.preimages.values()) {
-      const { key, Codec } = serialize.servicePreimages(serviceId, preimage.hash);
+      const { key, Codec } = serialize.servicePreimages(blake2b, serviceId, preimage.hash);
       serialized.set(key, Encoder.encodeObject(Codec, preimage.blob));
     }
 
     // storage
     for (const storage of service.data.storage.values()) {
-      const { key, Codec } = serialize.serviceStorage(serviceId, storage.key);
+      const { key, Codec } = serialize.serviceStorage(blake2b, serviceId, storage.key);
       serialized.set(key, Encoder.encodeObject(Codec, storage.value));
     }
 
     // lookup history
     for (const lookupHistoryList of service.data.lookupHistory.values()) {
       for (const lookupHistory of lookupHistoryList) {
-        const { key, Codec } = serialize.serviceLookupHistory(serviceId, lookupHistory.hash, lookupHistory.length);
+        const { key, Codec } = serialize.serviceLookupHistory(
+          blake2b,
+          serviceId,
+          lookupHistory.hash,
+          lookupHistory.length,
+        );
         serialized.set(key, Encoder.encodeObject(Codec, lookupHistory.slots.slice()));
       }
     }
@@ -11959,21 +12061,23 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
   implements State, EnumerableState
 {
   /** Create a state-like object from collection of serialized entries. */
-  static fromStateEntries(spec: ChainSpec, state: StateEntries, recentServices: ServiceId[] = []) {
-    return new SerializedState(spec, state, recentServices);
+  static fromStateEntries(spec: ChainSpec, blake2b: Blake2b, state: StateEntries, recentServices: ServiceId[] = []) {
+    return new SerializedState(spec, blake2b, state, recentServices);
   }
 
   /** Create a state-like object backed by some DB. */
   static new<T extends SerializedStateBackend>(
     spec: ChainSpec,
+    blake2b: Blake2b,
     db: T,
     recentServices: ServiceId[] = [],
   ): SerializedState<T> {
-    return new SerializedState(spec, db, recentServices);
+    return new SerializedState(spec, blake2b, db, recentServices);
   }
 
   private constructor(
     private readonly spec: ChainSpec,
+    private readonly blake2b: Blake2b,
     public backend: T,
     /** Best-effort list of recently active services. */
     private readonly _recentServiceIds: ServiceId[],
@@ -12004,7 +12108,7 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
       this._recentServiceIds.push(id);
     }
 
-    return new SerializedService(id, serviceData, (key) => this.retrieveOptional(key));
+    return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
   }
 
   private retrieve<T>({ key, Codec }: KeyAndCodec<T>, description: string): T {
@@ -12103,6 +12207,7 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
 /** Service data representation on a serialized state. */
 declare class SerializedService implements Service {
   constructor(
+    public readonly blake2b: Blake2b,
     /** Service id */
     public readonly serviceId: ServiceId,
     private readonly accountInfo: ServiceAccountInfo,
@@ -12118,14 +12223,14 @@ declare class SerializedService implements Service {
   getStorage(rawKey: StorageKey): BytesBlob | null {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const SERVICE_ID_BYTES = 4;
-      const serviceIdAndKey = new Uint8Array(SERVICE_ID_BYTES + rawKey.length);
+      const serviceIdAndKey = safeAllocUint8Array(SERVICE_ID_BYTES + rawKey.length);
       serviceIdAndKey.set(u32AsLeBytes(this.serviceId));
       serviceIdAndKey.set(rawKey.raw, SERVICE_ID_BYTES);
-      const key: StorageKey = asOpaqueType(BytesBlob.blobFrom(blake2b.hashBytes(serviceIdAndKey).raw));
-      return this.retrieveOptional(serialize.serviceStorage(this.serviceId, key)) ?? null;
+      const key: StorageKey = asOpaqueType(BytesBlob.blobFrom(this.blake2b.hashBytes(serviceIdAndKey).raw));
+      return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, key)) ?? null;
     }
 
-    return this.retrieveOptional(serialize.serviceStorage(this.serviceId, rawKey)) ?? null;
+    return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, rawKey)) ?? null;
   }
 
   /**
@@ -12135,17 +12240,17 @@ declare class SerializedService implements Service {
    */
   hasPreimage(hash: PreimageHash): boolean {
     // TODO [ToDr] consider optimizing to avoid fetching the whole data.
-    return this.retrieveOptional(serialize.servicePreimages(this.serviceId, hash)) !== undefined;
+    return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) !== undefined;
   }
 
   /** Retrieve preimage from the DB. */
   getPreimage(hash: PreimageHash): BytesBlob | null {
-    return this.retrieveOptional(serialize.servicePreimages(this.serviceId, hash)) ?? null;
+    return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) ?? null;
   }
 
   /** Retrieve preimage lookup history. */
   getLookupHistory(hash: PreimageHash, len: U32): LookupHistorySlots | null {
-    const rawSlots = this.retrieveOptional(serialize.serviceLookupHistory(this.serviceId, hash, len));
+    const rawSlots = this.retrieveOptional(serialize.serviceLookupHistory(this.blake2b, this.serviceId, hash, len));
     if (rawSlots === undefined) {
       return null;
     }
@@ -12158,9 +12263,9 @@ type KeyAndCodec<T> = {
   Codec: Decode<T>;
 };
 
-declare function loadState(spec: ChainSpec, entries: Iterable<[StateKey | TruncatedHash, BytesBlob]>) {
+declare function loadState(spec: ChainSpec, blake2b: Blake2b, entries: Iterable<[StateKey | TruncatedHash, BytesBlob]>) {
   const stateEntries = StateEntries.fromEntriesUnsafe(entries);
-  return SerializedState.fromStateEntries(spec, stateEntries);
+  return SerializedState.fromStateEntries(spec, blake2b, stateEntries);
 }
 
 /**
@@ -12189,44 +12294,44 @@ declare function loadState(spec: ChainSpec, entries: Iterable<[StateKey | Trunca
  *        hashmap of `key -> value` entries.
  */
 
-declare const index$b_EMPTY_BLOB: typeof EMPTY_BLOB;
-type index$b_EncodeFun = EncodeFun;
-type index$b_KeyAndCodec<T> = KeyAndCodec<T>;
-type index$b_SerializedService = SerializedService;
-declare const index$b_SerializedService: typeof SerializedService;
-type index$b_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
-declare const index$b_SerializedState: typeof SerializedState;
-type index$b_SerializedStateBackend = SerializedStateBackend;
-type index$b_StateCodec<T> = StateCodec<T>;
-type index$b_StateEntries = StateEntries;
-declare const index$b_StateEntries: typeof StateEntries;
-type index$b_StateEntryUpdate = StateEntryUpdate;
-type index$b_StateEntryUpdateAction = StateEntryUpdateAction;
-declare const index$b_StateEntryUpdateAction: typeof StateEntryUpdateAction;
-type index$b_StateKey = StateKey;
-type index$b_StateKeyIdx = StateKeyIdx;
-declare const index$b_StateKeyIdx: typeof StateKeyIdx;
-declare const index$b_TYPICAL_STATE_ITEMS: typeof TYPICAL_STATE_ITEMS;
-declare const index$b_TYPICAL_STATE_ITEM_LEN: typeof TYPICAL_STATE_ITEM_LEN;
-declare const index$b_U32_BYTES: typeof U32_BYTES;
-declare const index$b_binaryMerkleization: typeof binaryMerkleization;
-declare const index$b_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
-declare const index$b_dumpCodec: typeof dumpCodec;
-declare const index$b_getSafroleData: typeof getSafroleData;
-declare const index$b_legacyServiceNested: typeof legacyServiceNested;
-declare const index$b_loadState: typeof loadState;
-import index$b_serialize = serialize;
-declare const index$b_serializeBasicKeys: typeof serializeBasicKeys;
-declare const index$b_serializePreimages: typeof serializePreimages;
-declare const index$b_serializeRemovedServices: typeof serializeRemovedServices;
-declare const index$b_serializeServiceUpdates: typeof serializeServiceUpdates;
-declare const index$b_serializeStateUpdate: typeof serializeStateUpdate;
-declare const index$b_serializeStorage: typeof serializeStorage;
-declare const index$b_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
-import index$b_stateKeys = stateKeys;
-declare namespace index$b {
-  export { index$b_EMPTY_BLOB as EMPTY_BLOB, index$b_SerializedService as SerializedService, index$b_SerializedState as SerializedState, index$b_StateEntries as StateEntries, index$b_StateEntryUpdateAction as StateEntryUpdateAction, index$b_StateKeyIdx as StateKeyIdx, index$b_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$b_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$b_U32_BYTES as U32_BYTES, index$b_binaryMerkleization as binaryMerkleization, index$b_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$b_dumpCodec as dumpCodec, index$b_getSafroleData as getSafroleData, index$b_legacyServiceNested as legacyServiceNested, index$b_loadState as loadState, index$b_serialize as serialize, index$b_serializeBasicKeys as serializeBasicKeys, index$b_serializePreimages as serializePreimages, index$b_serializeRemovedServices as serializeRemovedServices, index$b_serializeServiceUpdates as serializeServiceUpdates, index$b_serializeStateUpdate as serializeStateUpdate, index$b_serializeStorage as serializeStorage, index$b_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$b_stateKeys as stateKeys };
-  export type { index$b_EncodeFun as EncodeFun, index$b_KeyAndCodec as KeyAndCodec, index$b_SerializedStateBackend as SerializedStateBackend, index$b_StateCodec as StateCodec, index$b_StateEntryUpdate as StateEntryUpdate, index$b_StateKey as StateKey };
+declare const index$d_EMPTY_BLOB: typeof EMPTY_BLOB;
+type index$d_EncodeFun = EncodeFun;
+type index$d_KeyAndCodec<T> = KeyAndCodec<T>;
+type index$d_SerializedService = SerializedService;
+declare const index$d_SerializedService: typeof SerializedService;
+type index$d_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
+declare const index$d_SerializedState: typeof SerializedState;
+type index$d_SerializedStateBackend = SerializedStateBackend;
+type index$d_StateCodec<T> = StateCodec<T>;
+type index$d_StateEntries = StateEntries;
+declare const index$d_StateEntries: typeof StateEntries;
+type index$d_StateEntryUpdate = StateEntryUpdate;
+type index$d_StateEntryUpdateAction = StateEntryUpdateAction;
+declare const index$d_StateEntryUpdateAction: typeof StateEntryUpdateAction;
+type index$d_StateKey = StateKey;
+type index$d_StateKeyIdx = StateKeyIdx;
+declare const index$d_StateKeyIdx: typeof StateKeyIdx;
+declare const index$d_TYPICAL_STATE_ITEMS: typeof TYPICAL_STATE_ITEMS;
+declare const index$d_TYPICAL_STATE_ITEM_LEN: typeof TYPICAL_STATE_ITEM_LEN;
+declare const index$d_U32_BYTES: typeof U32_BYTES;
+declare const index$d_binaryMerkleization: typeof binaryMerkleization;
+declare const index$d_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
+declare const index$d_dumpCodec: typeof dumpCodec;
+declare const index$d_getSafroleData: typeof getSafroleData;
+declare const index$d_legacyServiceNested: typeof legacyServiceNested;
+declare const index$d_loadState: typeof loadState;
+import index$d_serialize = serialize;
+declare const index$d_serializeBasicKeys: typeof serializeBasicKeys;
+declare const index$d_serializePreimages: typeof serializePreimages;
+declare const index$d_serializeRemovedServices: typeof serializeRemovedServices;
+declare const index$d_serializeServiceUpdates: typeof serializeServiceUpdates;
+declare const index$d_serializeStateUpdate: typeof serializeStateUpdate;
+declare const index$d_serializeStorage: typeof serializeStorage;
+declare const index$d_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
+import index$d_stateKeys = stateKeys;
+declare namespace index$d {
+  export { index$d_EMPTY_BLOB as EMPTY_BLOB, index$d_SerializedService as SerializedService, index$d_SerializedState as SerializedState, index$d_StateEntries as StateEntries, index$d_StateEntryUpdateAction as StateEntryUpdateAction, index$d_StateKeyIdx as StateKeyIdx, index$d_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$d_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$d_U32_BYTES as U32_BYTES, index$d_binaryMerkleization as binaryMerkleization, index$d_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$d_dumpCodec as dumpCodec, index$d_getSafroleData as getSafroleData, index$d_legacyServiceNested as legacyServiceNested, index$d_loadState as loadState, index$d_serialize as serialize, index$d_serializeBasicKeys as serializeBasicKeys, index$d_serializePreimages as serializePreimages, index$d_serializeRemovedServices as serializeRemovedServices, index$d_serializeServiceUpdates as serializeServiceUpdates, index$d_serializeStateUpdate as serializeStateUpdate, index$d_serializeStorage as serializeStorage, index$d_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$d_stateKeys as stateKeys };
+  export type { index$d_EncodeFun as EncodeFun, index$d_KeyAndCodec as KeyAndCodec, index$d_SerializedStateBackend as SerializedStateBackend, index$d_StateCodec as StateCodec, index$d_StateEntryUpdate as StateEntryUpdate, index$d_StateKey as StateKey };
 }
 
 /** Error during `LeafDb` creation. */
@@ -12316,7 +12421,8 @@ declare class LeafDb implements SerializedStateBackend {
     assertNever(val);
   }
 
-  getStateRoot(): StateRootHash {
+  getStateRoot(blake2b: Blake2b): StateRootHash {
+    const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
     return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leaves).asOpaque();
   }
 
@@ -12414,7 +12520,8 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   }
 
   async getStateRoot(state: InMemoryState): Promise<StateRootHash> {
-    return StateEntries.serializeInMemory(this.spec, state).getRootHash();
+    const blake2b = await Blake2b.createHasher();
+    return StateEntries.serializeInMemory(this.spec, blake2b, state).getRootHash(blake2b);
   }
 
   /** Insert a full state into the database. */
@@ -12434,25 +12541,25 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   }
 }
 
-type index$a_BlocksDb = BlocksDb;
-type index$a_InMemoryBlocks = InMemoryBlocks;
-declare const index$a_InMemoryBlocks: typeof InMemoryBlocks;
-type index$a_InMemoryStates = InMemoryStates;
-declare const index$a_InMemoryStates: typeof InMemoryStates;
-type index$a_LeafDb = LeafDb;
-declare const index$a_LeafDb: typeof LeafDb;
-type index$a_LeafDbError = LeafDbError;
-declare const index$a_LeafDbError: typeof LeafDbError;
-type index$a_Lookup = Lookup;
-type index$a_LookupKind = LookupKind;
-declare const index$a_LookupKind: typeof LookupKind;
-type index$a_StateUpdateError = StateUpdateError;
-declare const index$a_StateUpdateError: typeof StateUpdateError;
-type index$a_StatesDb<T extends State = State> = StatesDb<T>;
-type index$a_ValuesDb = ValuesDb;
-declare namespace index$a {
-  export { index$a_InMemoryBlocks as InMemoryBlocks, index$a_InMemoryStates as InMemoryStates, index$a_LeafDb as LeafDb, index$a_LeafDbError as LeafDbError, index$a_LookupKind as LookupKind, index$a_StateUpdateError as StateUpdateError };
-  export type { index$a_BlocksDb as BlocksDb, index$a_Lookup as Lookup, index$a_StatesDb as StatesDb, index$a_ValuesDb as ValuesDb };
+type index$c_BlocksDb = BlocksDb;
+type index$c_InMemoryBlocks = InMemoryBlocks;
+declare const index$c_InMemoryBlocks: typeof InMemoryBlocks;
+type index$c_InMemoryStates = InMemoryStates;
+declare const index$c_InMemoryStates: typeof InMemoryStates;
+type index$c_LeafDb = LeafDb;
+declare const index$c_LeafDb: typeof LeafDb;
+type index$c_LeafDbError = LeafDbError;
+declare const index$c_LeafDbError: typeof LeafDbError;
+type index$c_Lookup = Lookup;
+type index$c_LookupKind = LookupKind;
+declare const index$c_LookupKind: typeof LookupKind;
+type index$c_StateUpdateError = StateUpdateError;
+declare const index$c_StateUpdateError: typeof StateUpdateError;
+type index$c_StatesDb<T extends State = State> = StatesDb<T>;
+type index$c_ValuesDb = ValuesDb;
+declare namespace index$c {
+  export { index$c_InMemoryBlocks as InMemoryBlocks, index$c_InMemoryStates as InMemoryStates, index$c_LeafDb as LeafDb, index$c_LeafDbError as LeafDbError, index$c_LookupKind as LookupKind, index$c_StateUpdateError as StateUpdateError };
+  export type { index$c_BlocksDb as BlocksDb, index$c_Lookup as Lookup, index$c_StatesDb as StatesDb, index$c_ValuesDb as ValuesDb };
 }
 
 /**
@@ -12519,7 +12626,7 @@ declare function padAndEncodeData(input: BytesBlob) {
   const paddedLength = Math.ceil(input.length / PIECE_SIZE) * PIECE_SIZE;
   let padded = input;
   if (input.length !== paddedLength) {
-    padded = BytesBlob.blobFrom(new Uint8Array(paddedLength));
+    padded = BytesBlob.blobFrom(safeAllocUint8Array(paddedLength));
     padded.raw.set(input.raw, 0);
   }
   return chunkingFunction(padded);
@@ -12575,7 +12682,7 @@ declare function decodeData(input: FixedSizeArray<[number, BytesBlob], N_CHUNKS_
  */
 declare function encodePoints(input: Bytes<PIECE_SIZE>): FixedSizeArray<Bytes<POINT_LENGTH>, N_CHUNKS_TOTAL> {
   const result: Bytes<POINT_LENGTH>[] = [];
-  const data = new Uint8Array(POINT_ALIGNMENT * N_CHUNKS_REQUIRED);
+  const data = safeAllocUint8Array(POINT_ALIGNMENT * N_CHUNKS_REQUIRED);
 
   // add original shards to the result
   for (let i = 0; i < N_CHUNKS_REQUIRED; i++) {
@@ -12595,7 +12702,7 @@ declare function encodePoints(input: Bytes<PIECE_SIZE>): FixedSizeArray<Bytes<PO
   for (let i = 0; i < N_CHUNKS_REDUNDANCY; i++) {
     const pointIndex = i * POINT_ALIGNMENT;
 
-    const redundancyPoint = new Uint8Array(POINT_LENGTH);
+    const redundancyPoint = safeAllocUint8Array(POINT_LENGTH);
     for (let j = 0; j < POINT_LENGTH; j++) {
       redundancyPoint[j] = encodedData[pointIndex + j * HALF_POINT_SIZE];
     }
@@ -12615,7 +12722,7 @@ declare function decodePiece(
 ): Bytes<PIECE_SIZE> {
   const result = Bytes.zero(PIECE_SIZE);
 
-  const data = new Uint8Array(N_CHUNKS_REQUIRED * POINT_ALIGNMENT);
+  const data = safeAllocUint8Array(N_CHUNKS_REQUIRED * POINT_ALIGNMENT);
   const indices = new Uint16Array(input.length);
 
   for (let i = 0; i < N_CHUNKS_REQUIRED; i++) {
@@ -12742,163 +12849,704 @@ declare function lace<N extends number, K extends number>(input: FixedSizeArray<
     return BytesBlob.empty();
   }
   const n = input[0].length;
-  const result = BytesBlob.blobFrom(new Uint8Array(k * n));
+  const result = BytesBlob.blobFrom(safeAllocUint8Array(k * n));
   for (let i = 0; i < k; i++) {
     const entry = input[i].raw;
     for (let j = 0; j < n; j++) {
       result.raw[j * k + i] = entry[j];
     }
   }
-  return result;
+  return result;
+}
+
+/**
+ * `T`: Transposing function which accepts an array of `K` pieces of data
+ * which each have same lenght of `N` octets and returns an array of `N`
+ * pieces of data which each have length of `K` octets.
+ *
+ * T[[x0,0, x0,1, x0,2, . . . ], [x1,0, x1,1, . . . ], . . . ] ≡
+ * [[x0,0, x1,0, x2,0, . . . ], [x0,1, x1,1, . . . ], . . . ]
+ *
+ * https://graypaper.fluffylabs.dev/#/9a08063/3e2e023e2e02?v=0.6.6
+ */
+declare function transpose<T, N extends number, K extends number>(
+  input: FixedSizeArray<FixedSizeArray<T, K>, N>,
+  k: K,
+): FixedSizeArray<FixedSizeArray<T, N>, K> {
+  const n = input.fixedLength;
+  const columns: FixedSizeArray<T, N>[] = [];
+
+  for (let c = 0; c < k; c++) {
+    const newColumn: T[] = [];
+    for (let r = 0; r < n; r++) {
+      const cell = input[r][c];
+      newColumn.push(cell);
+    }
+    columns.push(FixedSizeArray.new(newColumn, n));
+  }
+  return FixedSizeArray.new(columns, k);
+}
+
+/**
+ * `C`: Erasure-code chunking function which accepts an arbitrary sized data blob whose
+ *       length divides wholly into `PIECE_SIZE` octets and results in `N_CHUNKS_TOTAL`
+ *       sequences of sequences, each of `POINT_LENGTH * K` octets blobs.
+ *       Where `K` is the number that divides input length by `PIECE_SIZE`.
+ *
+ *       Each element of resulting array is the same length.
+ *
+ * https://graypaper.fluffylabs.dev/#/9a08063/3f15003f1500?v=0.6.6
+ */
+declare function chunkingFunction(input: BytesBlob): FixedSizeArray<BytesBlob, N_CHUNKS_TOTAL> {
+  const k = Math.floor(input.length / PIECE_SIZE);
+  check`${k * PIECE_SIZE === input.length} Input length ${input.length} is not divisible by ${PIECE_SIZE}`;
+
+  // we get a `k` pieces.
+  const pieces = unzip<PIECE_SIZE, typeof k>(input, PIECE_SIZE, k);
+  // and each piece get's ec-codec
+  const points = pieces.map((p) => encodePoints(p));
+  // hence we end up with a matrix of `points * k`
+  type POINTS = FixedSizeArray<Bytes<POINT_LENGTH>, N_CHUNKS_TOTAL>;
+  const pointsTyped: FixedSizeArray<POINTS, typeof k> = FixedSizeArray.new(points, k);
+  // next we transpose the array, getting back an array of `N_CHUNKS_TOTAL` elements,
+  // where each element is a `k` points (`Bytes<POINT_LENGTH>`).
+  const transposed = transpose(pointsTyped, N_CHUNKS_TOTAL);
+  // lastly we join each element of that resulting array
+  // we get an array of `N_SHARDS_TOTAL` elements, each of length `POINT_LENGTH * k`.
+  const chunks = transposed.map((c) => join(c));
+  return FixedSizeArray.new(chunks, N_CHUNKS_TOTAL);
+}
+
+/** Split each validator's shard into numbered chunks it originally should have got. */
+declare function shardsToChunks(spec: ChainSpec, shards: PerValidator<BytesBlob>): PerValidator<[number, BytesBlob][]> {
+  const result: [number, BytesBlob][][] = [];
+
+  const shardSize = shards[0].length;
+  check`
+    ${shards.every((s) => s.length === shardSize)}
+    Each shard must be the same length!
+  `;
+
+  const totalData = shards.map((s) => s.length).reduce((sum, sLength) => sum + sLength, 0);
+  const chunkSize = Math.floor(totalData / N_CHUNKS_TOTAL);
+  const piecesPerChunk = Math.floor(shardSize / chunkSize);
+
+  let currentChunk = 0;
+  for (const s of shards) {
+    const validatorChunks: [number, BytesBlob][] = [];
+    for (let i = 0; i < piecesPerChunk; i++) {
+      const start = i * chunkSize;
+      const end = start + chunkSize;
+      const chunk = BytesBlob.blobFrom(s.raw.subarray(start, end));
+      // TODO [ToDr] we may possibly have not enough data for some of the chunk here
+      if (chunk.length === chunkSize) {
+        validatorChunks.push([currentChunk, chunk]);
+      }
+
+      currentChunk = (currentChunk + 1) % N_CHUNKS_TOTAL;
+    }
+    result.push(validatorChunks);
+  }
+
+  return tryAsPerValidator(result, spec);
+}
+
+/** Divide chunks between validators. */
+declare function chunksToShards(
+  spec: ChainSpec,
+  chunks: FixedSizeArray<BytesBlob, N_CHUNKS_TOTAL>,
+): PerValidator<BytesBlob> {
+  const result: BytesBlob[] = [];
+
+  const allChunks = BytesBlob.blobFromParts(chunks.map((c) => c.raw));
+  const shardSize = allChunks.length / N_CHUNKS_TOTAL;
+
+  // wrap around the data to have enough
+  const bytesToDrawFrom = BytesBlob.blobFromParts(allChunks.raw, allChunks.raw);
+  const bytesPerValidator = Math.ceil(allChunks.length / spec.validatorsCount);
+  // align number of bytes to the shard length.
+  const alignedBytesPerValidator = Math.ceil(bytesPerValidator / shardSize) * shardSize;
+
+  for (let i = 0; i < spec.validatorsCount; i++) {
+    const start = i * alignedBytesPerValidator;
+    const end = start + alignedBytesPerValidator;
+
+    result.push(BytesBlob.blobFrom(bytesToDrawFrom.raw.subarray(start, end)));
+  }
+
+  return tryAsPerValidator(result, spec);
+}
+
+declare const initEc = async () => {
+  await init.reedSolomon();
+};
+
+declare const index$b_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
+declare const index$b_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
+type index$b_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
+type index$b_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
+type index$b_PIECE_SIZE = PIECE_SIZE;
+declare const index$b_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
+type index$b_POINT_LENGTH = POINT_LENGTH;
+declare const index$b_checkConsistency: typeof checkConsistency;
+declare const index$b_chunkingFunction: typeof chunkingFunction;
+declare const index$b_chunksToShards: typeof chunksToShards;
+declare const index$b_decodeData: typeof decodeData;
+declare const index$b_decodeDataAndTrim: typeof decodeDataAndTrim;
+declare const index$b_decodePiece: typeof decodePiece;
+declare const index$b_encodePoints: typeof encodePoints;
+declare const index$b_initEc: typeof initEc;
+declare const index$b_join: typeof join;
+declare const index$b_lace: typeof lace;
+declare const index$b_padAndEncodeData: typeof padAndEncodeData;
+declare const index$b_shardsToChunks: typeof shardsToChunks;
+declare const index$b_split: typeof split;
+declare const index$b_transpose: typeof transpose;
+declare const index$b_unzip: typeof unzip;
+declare namespace index$b {
+  export { index$b_HALF_POINT_SIZE as HALF_POINT_SIZE, index$b_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$b_POINT_ALIGNMENT as POINT_ALIGNMENT, index$b_checkConsistency as checkConsistency, index$b_chunkingFunction as chunkingFunction, index$b_chunksToShards as chunksToShards, index$b_decodeData as decodeData, index$b_decodeDataAndTrim as decodeDataAndTrim, index$b_decodePiece as decodePiece, index$b_encodePoints as encodePoints, index$b_initEc as initEc, index$b_join as join, index$b_lace as lace, index$b_padAndEncodeData as padAndEncodeData, index$b_shardsToChunks as shardsToChunks, index$b_split as split, index$b_transpose as transpose, index$b_unzip as unzip };
+  export type { index$b_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$b_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$b_PIECE_SIZE as PIECE_SIZE, index$b_POINT_LENGTH as POINT_LENGTH };
+}
+
+/** A per-client handler of incoming socket messages. */
+interface IpcHandler {
+  /** New data on the socket received. */
+  onSocketMessage(msg: Uint8Array): Promise<void>;
+
+  /** Socket closed or errored. */
+  onClose(reason: { error?: Error }): void;
+}
+
+/** Sending data abstraction on a socket. */
+interface IpcSender {
+  /** Write given data to the outgoing socket. */
+  send(data: BytesBlob): void;
+
+  /** Close the socket. */
+  close(): void;
+}
+
+/**
+ * Version ::= SEQUENCE {
+ *     major INTEGER (0..255),
+ *     minor INTEGER (0..255),
+ *     patch INTEGER (0..255)
+ * }
+ */
+declare class Version extends WithDebug {
+  static Codec = codec.Class(Version, {
+    major: codec.u8,
+    minor: codec.u8,
+    patch: codec.u8,
+  });
+
+  static tryFromString(str: string): Version {
+    const parse = (v: string) => tryAsU8(Number(v));
+    try {
+      const [major, minor, patch] = str.trim().split(".").map(parse);
+
+      return Version.create({
+        major,
+        minor,
+        patch,
+      });
+    } catch (e) {
+      throw new Error(`Unable to parse ${str} as Version: ${e}`);
+    }
+  }
+
+  static create({ major, minor, patch }: CodecRecord<Version>) {
+    return new Version(major, minor, patch);
+  }
+
+  private constructor(
+    public readonly major: U8,
+    public readonly minor: U8,
+    public readonly patch: U8,
+  ) {
+    super();
+  }
+}
+
+/**
+ * Fuzzer Protocol V1
+ * Reference: https://github.com/davxy/jam-conformance/blob/main/fuzz-proto/fuzz.asn
+ */
+// Feature bit constants
+declare enum Features {
+  Ancestry = 1, // 2^0
+  Fork = 2, // 2^1
+  Reserved = 2147483648, // 2^31
+}
+
+/**
+ * PeerInfo ::= SEQUENCE {
+ *     fuzz-version U8,
+ *     features     Features,
+ *     jam-version  Version,
+ *     app-version  Version,
+ *     name         UTF8String
+ * }
+ */
+declare class PeerInfo extends WithDebug {
+  static Codec = codec.Class(PeerInfo, {
+    fuzzVersion: codec.u8,
+    features: codec.u32,
+    jamVersion: Version.Codec,
+    appVersion: Version.Codec,
+    name: codec.string,
+  });
+
+  static create({ fuzzVersion, features, appVersion, jamVersion, name }: CodecRecord<PeerInfo>) {
+    return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
+  }
+
+  private constructor(
+    public readonly fuzzVersion: U8,
+    public readonly features: U32,
+    public readonly jamVersion: Version,
+    public readonly appVersion: Version,
+    public readonly name: string,
+  ) {
+    super();
+  }
+}
+
+/**
+ * AncestryItem ::= SEQUENCE {
+ *     slot TimeSlot,
+ *     header-hash HeaderHash
+ * }
+ */
+declare class AncestryItem extends WithDebug {
+  static Codec = codec.Class(AncestryItem, {
+    slot: codec.u32.asOpaque<TimeSlot>(),
+    headerHash: codec.bytes(HASH_SIZE).asOpaque<HeaderHash>(),
+  });
+
+  static create({ slot, headerHash }: CodecRecord<AncestryItem>) {
+    return new AncestryItem(slot, headerHash);
+  }
+
+  private constructor(
+    public readonly slot: TimeSlot,
+    public readonly headerHash: HeaderHash,
+  ) {
+    super();
+  }
+}
+
+/**
+ * KeyValue ::= SEQUENCE {
+ *     key     TrieKey,
+ *     value   OCTET STRING
+ * }
+ */
+declare class KeyValue extends WithDebug {
+  static Codec = codec.Class(KeyValue, {
+    key: codec.bytes(TRUNCATED_HASH_SIZE),
+    value: codec.blob,
+  });
+
+  static create({ key, value }: CodecRecord<KeyValue>) {
+    return new KeyValue(key, value);
+  }
+
+  private constructor(
+    public readonly key: TruncatedHash,
+    public readonly value: BytesBlob,
+  ) {
+    super();
+  }
+}
+
+/** State ::= SEQUENCE OF KeyValue */
+declare const stateCodec = codec.sequenceVarLen(KeyValue.Codec);
+
+/**
+ * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
+ * Empty when `feature-ancestry` is not supported by both parties
+ */
+declare const ancestryCodec = codec.sequenceVarLen(AncestryItem.Codec, {
+  minLength: 0,
+  maxLength: 24,
+});
+type Ancestry = AncestryItem[];
+
+/**
+ * Initialize ::= SEQUENCE {
+ *     header Header,
+ *     keyvals State,
+ *     ancestry Ancestry
+ * }
+ */
+declare class Initialize extends WithDebug {
+  static Codec = codec.Class(Initialize, {
+    header: Header.Codec,
+    keyvals: stateCodec,
+    ancestry: ancestryCodec,
+  });
+
+  static create({ header, keyvals, ancestry }: CodecRecord<Initialize>) {
+    return new Initialize(header, keyvals, ancestry);
+  }
+
+  private constructor(
+    public readonly header: Header,
+    public readonly keyvals: KeyValue[],
+    public readonly ancestry: Ancestry,
+  ) {
+    super();
+  }
+}
+
+/** GetState ::= HeaderHash */
+declare const getStateCodec = codec.bytes(HASH_SIZE).asOpaque<HeaderHash>();
+type GetState = HeaderHash;
+
+/** StateRoot ::= StateRootHash */
+declare const stateRootCodec = codec.bytes(HASH_SIZE).asOpaque<StateRootHash>();
+type StateRoot = StateRootHash;
+
+/** Error ::= UTF8String */
+declare class ErrorMessage extends WithDebug {
+  static Codec = codec.Class(ErrorMessage, {
+    message: codec.string,
+  });
+
+  static create({ message }: CodecRecord<ErrorMessage>): ErrorMessage {
+    return new ErrorMessage(message);
+  }
+
+  private constructor(public readonly message: string) {
+    super();
+  }
+}
+
+/** Message choice type tags */
+declare enum MessageType {
+  PeerInfo = 0,
+  Initialize = 1,
+  StateRoot = 2,
+  ImportBlock = 3,
+  GetState = 4,
+  State = 5,
+  Error = 255,
 }
 
+/** Message data union */
+type MessageData =
+  | { type: MessageType.PeerInfo; value: PeerInfo }
+  | { type: MessageType.Initialize; value: Initialize }
+  | { type: MessageType.StateRoot; value: StateRoot }
+  | { type: MessageType.ImportBlock; value: BlockView }
+  | { type: MessageType.GetState; value: GetState }
+  | { type: MessageType.State; value: KeyValue[] }
+  | { type: MessageType.Error; value: ErrorMessage };
+
 /**
- * `T`: Transposing function which accepts an array of `K` pieces of data
- * which each have same lenght of `N` octets and returns an array of `N`
- * pieces of data which each have length of `K` octets.
- *
- * T[[x0,0, x0,1, x0,2, . . . ], [x1,0, x1,1, . . . ], . . . ] ≡
- * [[x0,0, x1,0, x2,0, . . . ], [x0,1, x1,1, . . . ], . . . ]
- *
- * https://graypaper.fluffylabs.dev/#/9a08063/3e2e023e2e02?v=0.6.6
+ * Message ::= CHOICE {
+ *     peer-info     [0] PeerInfo,
+ *     initialize    [1] Initialize,
+ *     state-root    [2] StateRoot,
+ *     import-block  [3] ImportBlock,
+ *     get-state     [4] GetState,
+ *     state         [5] State,
+ *     error         [255] Error
+ * }
  */
-declare function transpose<T, N extends number, K extends number>(
-  input: FixedSizeArray<FixedSizeArray<T, K>, N>,
-  k: K,
-): FixedSizeArray<FixedSizeArray<T, N>, K> {
-  const n = input.fixedLength;
-  const columns: FixedSizeArray<T, N>[] = [];
-
-  for (let c = 0; c < k; c++) {
-    const newColumn: T[] = [];
-    for (let r = 0; r < n; r++) {
-      const cell = input[r][c];
-      newColumn.push(cell);
+declare const messageCodec = codec.custom<MessageData>(
+  {
+    name: "Message",
+    sizeHint: { bytes: 1, isExact: false },
+  },
+  (e, msg) => {
+    e.i8(msg.type);
+    switch (msg.type) {
+      case MessageType.PeerInfo:
+        PeerInfo.Codec.encode(e, msg.value);
+        break;
+      case MessageType.Initialize:
+        Initialize.Codec.encode(e, msg.value);
+        break;
+      case MessageType.StateRoot:
+        stateRootCodec.encode(e, msg.value);
+        break;
+      case MessageType.ImportBlock:
+        Block.Codec.View.encode(e, msg.value);
+        break;
+      case MessageType.GetState:
+        getStateCodec.encode(e, msg.value);
+        break;
+      case MessageType.State:
+        stateCodec.encode(e, msg.value);
+        break;
+      case MessageType.Error:
+        ErrorMessage.Codec.encode(e, msg.value);
+        break;
+      default:
+        throw new Error(`Unknown message type: ${msg}`);
     }
-    columns.push(FixedSizeArray.new(newColumn, n));
-  }
-  return FixedSizeArray.new(columns, k);
-}
+  },
+  (d): MessageData => {
+    const type = d.u8();
+    switch (type) {
+      case MessageType.PeerInfo:
+        return { type: MessageType.PeerInfo, value: PeerInfo.Codec.decode(d) };
+      case MessageType.Initialize:
+        return { type: MessageType.Initialize, value: Initialize.Codec.decode(d) };
+      case MessageType.StateRoot:
+        return { type: MessageType.StateRoot, value: stateRootCodec.decode(d) };
+      case MessageType.ImportBlock:
+        return { type: MessageType.ImportBlock, value: Block.Codec.View.decode(d) };
+      case MessageType.GetState:
+        return { type: MessageType.GetState, value: getStateCodec.decode(d) };
+      case MessageType.State:
+        return { type: MessageType.State, value: stateCodec.decode(d) };
+      case MessageType.Error:
+        return { type: MessageType.Error, value: ErrorMessage.Codec.decode(d) };
+      default:
+        throw new Error(`Unknown message type: ${type}`);
+    }
+  },
+  (s) => {
+    const type = s.decoder.u8();
+    switch (type) {
+      case MessageType.PeerInfo:
+        PeerInfo.Codec.View.skip(s);
+        break;
+      case MessageType.Initialize:
+        Initialize.Codec.View.skip(s);
+        break;
+      case MessageType.StateRoot:
+        stateRootCodec.View.skip(s);
+        break;
+      case MessageType.ImportBlock:
+        Block.Codec.View.skip(s);
+        break;
+      case MessageType.GetState:
+        getStateCodec.View.skip(s);
+        break;
+      case MessageType.State:
+        stateCodec.View.skip(s);
+        break;
+      case MessageType.Error:
+        ErrorMessage.Codec.View.skip(s);
+        break;
+      default:
+        throw new Error(`Unknown message type: ${type}`);
+    }
+  },
+);
+
+type Message = MessageData;
+
+declare const logger$1 = Logger.new(import.meta.filename, "ext-ipc-fuzz-v1");
 
 /**
- * `C`: Erasure-code chunking function which accepts an arbitrary sized data blob whose
- *       length divides wholly into `PIECE_SIZE` octets and results in `N_CHUNKS_TOTAL`
- *       sequences of sequences, each of `POINT_LENGTH * K` octets blobs.
- *       Where `K` is the number that divides input length by `PIECE_SIZE`.
- *
- *       Each element of resulting array is the same length.
- *
- * https://graypaper.fluffylabs.dev/#/9a08063/3f15003f1500?v=0.6.6
+ * Handler interface for v1 fuzzer protocol messages.
+ * https://github.com/davxy/jam-conformance/blob/main/fuzz-proto/fuzz-v1.asn
  */
-declare function chunkingFunction(input: BytesBlob): FixedSizeArray<BytesBlob, N_CHUNKS_TOTAL> {
-  const k = Math.floor(input.length / PIECE_SIZE);
-  check`${k * PIECE_SIZE === input.length} Input length ${input.length} is not divisible by ${PIECE_SIZE}`;
+interface FuzzMessageHandler {
+  /**
+   * Handshake and versioning exchange.
+   * Target waits to receive the fuzzer's PeerInfo message before sending its own.
+   */
+  getPeerInfo(value: PeerInfo): Promise<PeerInfo>;
 
-  // we get a `k` pieces.
-  const pieces = unzip<PIECE_SIZE, typeof k>(input, PIECE_SIZE, k);
-  // and each piece get's ec-codec
-  const points = pieces.map((p) => encodePoints(p));
-  // hence we end up with a matrix of `points * k`
-  type POINTS = FixedSizeArray<Bytes<POINT_LENGTH>, N_CHUNKS_TOTAL>;
-  const pointsTyped: FixedSizeArray<POINTS, typeof k> = FixedSizeArray.new(points, k);
-  // next we transpose the array, getting back an array of `N_CHUNKS_TOTAL` elements,
-  // where each element is a `k` points (`Bytes<POINT_LENGTH>`).
-  const transposed = transpose(pointsTyped, N_CHUNKS_TOTAL);
-  // lastly we join each element of that resulting array
-  // we get an array of `N_SHARDS_TOTAL` elements, each of length `POINT_LENGTH * k`.
-  const chunks = transposed.map((c) => join(c));
-  return FixedSizeArray.new(chunks, N_CHUNKS_TOTAL);
+  /**
+   * Initialize or reset target state.
+   * Returns the state root of the initialized state.
+   */
+  initialize(header: Initialize): Promise<StateRootHash>;
+
+  /**
+   * Process block and return resulting state root.
+   * May return an Error if the block import fails.
+   */
+  importBlock(value: BlockView): Promise<Result$2<StateRootHash, ErrorMessage>>;
+
+  /** Retrieve posterior state associated to given header hash. */
+  getSerializedState(value: HeaderHash): Promise<KeyValue[]>;
 }
 
-/** Split each validator's shard into numbered chunks it originally should have got. */
-declare function shardsToChunks(spec: ChainSpec, shards: PerValidator<BytesBlob>): PerValidator<[number, BytesBlob][]> {
-  const result: [number, BytesBlob][][] = [];
+declare class FuzzTarget implements IpcHandler {
+  private sessionFeatures = 0;
 
-  const shardSize = shards[0].length;
-  check`
-    ${shards.every((s) => s.length === shardSize)}
-    Each shard must be the same length!
-  `;
+  constructor(
+    public readonly msgHandler: FuzzMessageHandler,
+    public readonly sender: IpcSender,
+    public readonly spec: ChainSpec,
+  ) {}
 
-  const totalData = shards.map((s) => s.length).reduce((sum, sLength) => sum + sLength, 0);
-  const chunkSize = Math.floor(totalData / N_CHUNKS_TOTAL);
-  const piecesPerChunk = Math.floor(shardSize / chunkSize);
+  async onSocketMessage(msg: Uint8Array): Promise<void> {
+    // attempt to decode the messsage
+    try {
+      const message = Decoder.decodeObject(messageCodec, msg, this.spec);
+      logger.log`[${message.type}] incoming message`;
 
-  let currentChunk = 0;
-  for (const s of shards) {
-    const validatorChunks: [number, BytesBlob][] = [];
-    for (let i = 0; i < piecesPerChunk; i++) {
-      const start = i * chunkSize;
-      const end = start + chunkSize;
-      const chunk = BytesBlob.blobFrom(s.raw.subarray(start, end));
-      // TODO [ToDr] we may possibly have not enough data for some of the chunk here
-      if (chunk.length === chunkSize) {
-        validatorChunks.push([currentChunk, chunk]);
+      await this.processAndRespond(message);
+    } catch (e) {
+      logger.error`Error while processing fuzz v1 message: ${e}`;
+      logger.error`${e}`;
+      if (e instanceof Error) {
+        logger.error`${e.stack ?? ""}`;
       }
-
-      currentChunk = (currentChunk + 1) % N_CHUNKS_TOTAL;
+      this.sender.close();
     }
-    result.push(validatorChunks);
   }
 
-  return tryAsPerValidator(result, spec);
-}
+  private async processAndRespond(message: MessageData): Promise<void> {
+    let response: Message | null = null;
 
-/** Divide chunks between validators. */
-declare function chunksToShards(
-  spec: ChainSpec,
-  chunks: FixedSizeArray<BytesBlob, N_CHUNKS_TOTAL>,
-): PerValidator<BytesBlob> {
-  const result: BytesBlob[] = [];
+    switch (message.type) {
+      case MessageType.PeerInfo: {
+        // only support V1
+        if (message.value.fuzzVersion !== 1) {
+          logger.warn`Unsupported fuzzer protocol version: ${message.value.fuzzVersion}. Closing`;
+          this.sender.close();
+          return;
+        }
 
-  const allChunks = BytesBlob.blobFromParts(chunks.map((c) => c.raw));
-  const shardSize = allChunks.length / N_CHUNKS_TOTAL;
+        // Handle handshake
+        const ourPeerInfo = await this.msgHandler.getPeerInfo(message.value);
 
-  // wrap around the data to have enough
-  const bytesToDrawFrom = BytesBlob.blobFromParts(allChunks.raw, allChunks.raw);
-  const bytesPerValidator = Math.ceil(allChunks.length / spec.validatorsCount);
-  // align number of bytes to the shard length.
-  const alignedBytesPerValidator = Math.ceil(bytesPerValidator / shardSize) * shardSize;
+        // Calculate session features (intersection of both peer features)
+        this.sessionFeatures = message.value.features & ourPeerInfo.features;
 
-  for (let i = 0; i < spec.validatorsCount; i++) {
-    const start = i * alignedBytesPerValidator;
-    const end = start + alignedBytesPerValidator;
+        logger.info`Handshake completed. Shared features: 0b${this.sessionFeatures.toString(2)}`;
+        logger.log`Feature ancestry: ${(this.sessionFeatures & Features.Ancestry) !== 0}`;
+        logger.log`Feature fork: ${(this.sessionFeatures & Features.Fork) !== 0}`;
 
-    result.push(BytesBlob.blobFrom(bytesToDrawFrom.raw.subarray(start, end)));
-  }
+        response = {
+          type: MessageType.PeerInfo,
+          value: ourPeerInfo,
+        };
+        break;
+      }
 
-  return tryAsPerValidator(result, spec);
-}
+      case MessageType.Initialize: {
+        const stateRoot = await this.msgHandler.initialize(message.value);
+        response = {
+          type: MessageType.StateRoot,
+          value: stateRoot,
+        };
+        break;
+      }
 
-declare const initEc = async () => {
-  await init.reedSolomon();
-};
+      case MessageType.ImportBlock: {
+        const result = await this.msgHandler.importBlock(message.value);
+
+        if (result.isOk) {
+          response = {
+            type: MessageType.StateRoot,
+            value: result.ok,
+          };
+        } else {
+          response = {
+            type: MessageType.Error,
+            value: result.error,
+          };
+        }
+        break;
+      }
+
+      case MessageType.GetState: {
+        const state = await this.msgHandler.getSerializedState(message.value);
+        response = {
+          type: MessageType.State,
+          value: state,
+        };
+        break;
+      }
 
-declare const index$9_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
-declare const index$9_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
-type index$9_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
-type index$9_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
-type index$9_PIECE_SIZE = PIECE_SIZE;
-declare const index$9_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
-type index$9_POINT_LENGTH = POINT_LENGTH;
-declare const index$9_checkConsistency: typeof checkConsistency;
-declare const index$9_chunkingFunction: typeof chunkingFunction;
-declare const index$9_chunksToShards: typeof chunksToShards;
-declare const index$9_decodeData: typeof decodeData;
-declare const index$9_decodeDataAndTrim: typeof decodeDataAndTrim;
-declare const index$9_decodePiece: typeof decodePiece;
-declare const index$9_encodePoints: typeof encodePoints;
-declare const index$9_initEc: typeof initEc;
-declare const index$9_join: typeof join;
-declare const index$9_lace: typeof lace;
-declare const index$9_padAndEncodeData: typeof padAndEncodeData;
-declare const index$9_shardsToChunks: typeof shardsToChunks;
-declare const index$9_split: typeof split;
-declare const index$9_transpose: typeof transpose;
-declare const index$9_unzip: typeof unzip;
+      case MessageType.StateRoot: {
+        logger.log`--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`;
+        this.sender.close();
+        return;
+      }
+
+      case MessageType.State: {
+        logger.log`--> Received unexpected 'State' message from the fuzzer. Closing.`;
+        this.sender.close();
+        return;
+      }
+
+      case MessageType.Error: {
+        logger.log`--> Received unexpected 'Error' message from the fuzzer. Closing.`;
+        this.sender.close();
+        return;
+      }
+
+      default: {
+        logger.log`--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`;
+        this.sender.close();
+        try {
+          assertNever(message);
+        } catch {
+          return;
+        }
+      }
+    }
+
+    if (response !== null) {
+      logger.trace`<-- responding with: ${response.type}`;
+      const encoded = Encoder.encodeObject(messageCodec, response, this.spec);
+      this.sender.send(encoded);
+    } else {
+      logger.warn`<-- no response generated for: ${message.type}`;
+    }
+  }
+
+  onClose({ error }: { error?: Error }): void {
+    logger.log`Closing the v1 handler. Reason: ${error !== undefined ? error.message : "close"}.`;
+  }
+
+  /** Check if a specific feature is enabled in the session */
+  hasFeature(feature: number): boolean {
+    return (this.sessionFeatures & feature) !== 0;
+  }
+}
+
+type index$a_Ancestry = Ancestry;
+type index$a_AncestryItem = AncestryItem;
+declare const index$a_AncestryItem: typeof AncestryItem;
+type index$a_ErrorMessage = ErrorMessage;
+declare const index$a_ErrorMessage: typeof ErrorMessage;
+type index$a_Features = Features;
+declare const index$a_Features: typeof Features;
+type index$a_FuzzMessageHandler = FuzzMessageHandler;
+type index$a_FuzzTarget = FuzzTarget;
+declare const index$a_FuzzTarget: typeof FuzzTarget;
+type index$a_GetState = GetState;
+type index$a_Initialize = Initialize;
+declare const index$a_Initialize: typeof Initialize;
+type index$a_KeyValue = KeyValue;
+declare const index$a_KeyValue: typeof KeyValue;
+type index$a_Message = Message;
+type index$a_MessageData = MessageData;
+type index$a_MessageType = MessageType;
+declare const index$a_MessageType: typeof MessageType;
+type index$a_PeerInfo = PeerInfo;
+declare const index$a_PeerInfo: typeof PeerInfo;
+type index$a_StateRoot = StateRoot;
+type index$a_Version = Version;
+declare const index$a_Version: typeof Version;
+declare const index$a_ancestryCodec: typeof ancestryCodec;
+declare const index$a_getStateCodec: typeof getStateCodec;
+declare const index$a_messageCodec: typeof messageCodec;
+declare const index$a_stateCodec: typeof stateCodec;
+declare const index$a_stateRootCodec: typeof stateRootCodec;
+declare namespace index$a {
+  export { index$a_AncestryItem as AncestryItem, index$a_ErrorMessage as ErrorMessage, index$a_Features as Features, index$a_FuzzTarget as FuzzTarget, index$a_Initialize as Initialize, index$a_KeyValue as KeyValue, index$a_MessageType as MessageType, index$a_PeerInfo as PeerInfo, index$a_Version as Version, index$a_ancestryCodec as ancestryCodec, index$a_getStateCodec as getStateCodec, logger$1 as logger, index$a_messageCodec as messageCodec, index$a_stateCodec as stateCodec, index$a_stateRootCodec as stateRootCodec };
+  export type { index$a_Ancestry as Ancestry, index$a_FuzzMessageHandler as FuzzMessageHandler, index$a_GetState as GetState, index$a_Message as Message, index$a_MessageData as MessageData, index$a_StateRoot as StateRoot };
+}
+
+type index$9_IpcHandler = IpcHandler;
+type index$9_IpcSender = IpcSender;
 declare namespace index$9 {
-  export { index$9_HALF_POINT_SIZE as HALF_POINT_SIZE, index$9_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$9_POINT_ALIGNMENT as POINT_ALIGNMENT, index$9_checkConsistency as checkConsistency, index$9_chunkingFunction as chunkingFunction, index$9_chunksToShards as chunksToShards, index$9_decodeData as decodeData, index$9_decodeDataAndTrim as decodeDataAndTrim, index$9_decodePiece as decodePiece, index$9_encodePoints as encodePoints, index$9_initEc as initEc, index$9_join as join, index$9_lace as lace, index$9_padAndEncodeData as padAndEncodeData, index$9_shardsToChunks as shardsToChunks, index$9_split as split, index$9_transpose as transpose, index$9_unzip as unzip };
-  export type { index$9_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$9_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$9_PIECE_SIZE as PIECE_SIZE, index$9_POINT_LENGTH as POINT_LENGTH };
+  export { index$a as v1 };
+  export type { index$9_IpcHandler as IpcHandler, index$9_IpcSender as IpcSender };
 }
 
 /** Size of the transfer memo. */
@@ -13044,6 +13692,8 @@ declare enum NewServiceError {
   InsufficientFunds = 0,
   /** Service is not privileged to set gratis storage. */
   UnprivilegedService = 1,
+  /** Registrar attempting to create a service with already existing id. */
+  RegistrarServiceIdAlreadyTaken = 2,
 }
 
 declare enum UpdatePrivilegesError {
@@ -13099,25 +13749,28 @@ interface PartialState {
 
   /**
    * Transfer given `amount` of funds to the `destination`,
-   * passing `suppliedGas` to invoke `OnTransfer` entry point
-   * and given `memo`.
+   * passing `gas` fee for transfer and given `memo`.
    */
   transfer(
     destination: ServiceId | null,
     amount: U64,
-    suppliedGas: ServiceGas,
+    gas: ServiceGas,
     memo: Bytes<TRANSFER_MEMO_BYTES>,
   ): Result$2<OK, TransferError>;
 
   /**
-   * Create a new service with given codeHash, length, gas, allowance and gratisStorage.
+   * Create a new service with given codeHash, length, gas, allowance, gratisStorage and wantedServiceId.
+   *
+   * Returns a newly assigned id
+   * or `wantedServiceId` if it's lower than `S`
+   * and parent of that service is `Registrar`.
    *
-   * Returns a newly assigned id of that service.
-   * https://graypaper.fluffylabs.dev/#/7e6ff6a/2f4c022f4c02?v=0.6.7
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/2fa9042fc304?v=0.7.2
    *
    * An error can be returned in case the account does not
    * have the required balance
-   * or tries to set gratis storage without being privileged.
+   * or tries to set gratis storage without being `Manager`
+   * or `Registrar` tries to set service id thats already taken.
    */
   newService(
     codeHash: CodeHash,
@@ -13125,6 +13778,7 @@ interface PartialState {
     gas: ServiceGas,
     allowance: ServiceGas,
     gratisStorage: U64,
+    wantedServiceId: U64,
   ): Result$2<ServiceId, NewServiceError>;
 
   /** Upgrade code of currently running service. */
@@ -13146,7 +13800,7 @@ interface PartialState {
   updateAuthorizationQueue(
     coreIndex: CoreIndex,
     authQueue: FixedSizeArray<Blake2bHash, AUTHORIZATION_QUEUE_SIZE>,
-    authManager: ServiceId | null,
+    assigners: ServiceId | null,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /**
@@ -13155,14 +13809,16 @@ interface PartialState {
    * `m`: manager service (can change privileged services)
    * `a`: manages authorization queue
    * `v`: manages validator keys
-   * `g`: collection of serviceId -> gas that auto-accumulate every block
+   * `r`: manages create new services in protected id range.
+   * `z`: collection of serviceId -> gas that auto-accumulate every block
    *
    */
   updatePrivilegedServices(
     m: ServiceId | null,
     a: PerCore<ServiceId>,
     v: ServiceId | null,
-    g: [ServiceId, ServiceGas][],
+    r: ServiceId | null,
+    z: [ServiceId, ServiceGas][],
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /** Yield accumulation trie result hash. */
@@ -13274,7 +13930,7 @@ declare class Mask {
   }
 
   private buildLookupTableForward(mask: BitVec) {
-    const table = new Uint8Array(mask.bitLength);
+    const table = safeAllocUint8Array(mask.bitLength);
     let lastInstructionOffset = 0;
     for (let i = mask.bitLength - 1; i >= 0; i--) {
       if (mask.isSet(i)) {
@@ -13418,7 +14074,7 @@ declare class Registers {
   private asSigned: BigInt64Array;
   private asUnsigned: BigUint64Array;
 
-  constructor(private readonly bytes = new Uint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
+  constructor(private readonly bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
     check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
     this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
     this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
@@ -14780,11 +15436,12 @@ declare class MemoryBuilder {
     `;
     this.ensureNotFinalized();
 
-    const range = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
-    const pages = PageRange.fromMemoryRange(range);
+    const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
+    const heapPagesRange = PageRange.fromMemoryRange(heapRange);
+    const initializedPageNumbers = Array.from(this.initialMemory.keys());
 
-    for (const pageNumber of pages) {
-      if (this.initialMemory.has(pageNumber)) {
+    for (const pageNumber of initializedPageNumbers) {
+      if (heapPagesRange.isInRange(pageNumber)) {
         throw new IncorrectSbrkIndex();
       }
     }
@@ -17079,7 +17736,7 @@ declare class AccumulationStateUpdate {
     /** Services state updates. */
     public readonly services: ServicesUpdate,
     /** Pending transfers. */
-    public readonly transfers: PendingTransfer[],
+    public transfers: PendingTransfer[],
     /** Yielded accumulation root. */
     public readonly yieldedRoots: Map<ServiceId, OpaqueHash> = new Map(),
   ) {}
@@ -17130,11 +17787,18 @@ declare class AccumulationStateUpdate {
     if (from.privilegedServices !== null) {
       update.privilegedServices = PrivilegedServices.create({
         ...from.privilegedServices,
-        authManager: asKnownSize([...from.privilegedServices.authManager]),
+        assigners: asKnownSize([...from.privilegedServices.assigners]),
       });
     }
     return update;
   }
+
+  /** Retrieve and clear pending transfers. */
+  takeTransfers() {
+    const transfers = this.transfers;
+    this.transfers = [];
+    return transfers;
+  }
 }
 
 type StateSlice = Pick<State, "getService" | "privilegedServices">;
@@ -17401,7 +18065,7 @@ declare const HostCallResult = {
   OOB: tryAsU64(0xffff_ffff_ffff_fffdn), // 2**64 - 3
   /** Index unknown. */
   WHO: tryAsU64(0xffff_ffff_ffff_fffcn), // 2**64 - 4
-  /** Storage full. */
+  /** Storage full or resource already allocated. */
   FULL: tryAsU64(0xffff_ffff_ffff_fffbn), // 2**64 - 5
   /** Core index unknown. */
   CORE: tryAsU64(0xffff_ffff_ffff_fffan), // 2**64 - 6
@@ -17409,7 +18073,7 @@ declare const HostCallResult = {
   CASH: tryAsU64(0xffff_ffff_ffff_fff9n), // 2**64 - 7
   /** Gas limit too low. */
   LOW: tryAsU64(0xffff_ffff_ffff_fff8n), // 2**64 - 8
-  /** The item is already solicited or cannot be forgotten. */
+  /** The item is already solicited, cannot be forgotten or the operation is invalid due to privilege level. */
   HUH: tryAsU64(0xffff_ffff_ffff_fff7n), // 2**64 - 9
   /** The return value indicating general success. */
   OK: tryAsU64(0n),
@@ -17475,9 +18139,15 @@ type HostCallIndex = Opaque<U32, "HostCallIndex[U32]">;
 /** Attempt to convert a number into `HostCallIndex`. */
 declare const tryAsHostCallIndex = (v: number): HostCallIndex => asOpaqueType(tryAsU32(v));
 
+/**
+ * Host-call exit reason.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a30124a501?v=0.7.2
+ */
 declare enum PvmExecution {
   Halt = 0,
   Panic = 1,
+  OOG = 2, // out-of-gas
 }
 
 /** A utility function to easily trace a bunch of registers. */
@@ -17490,8 +18160,12 @@ interface HostCallHandler {
   /** Index of that host call (i.e. what PVM invokes via `ecalli`) */
   readonly index: HostCallIndex;
 
-  /** The gas cost of invocation of that host call. */
-  readonly gasCost: SmallGas | ((reg: IHostCallRegisters) => Gas);
+  /**
+   * The gas cost of invocation of that host call.
+   *
+   * NOTE: `((reg: IHostCallRegisters) => Gas)` function is for compatibility reasons: pre GP 0.7.2
+   */
+  readonly basicGasCost: SmallGas | ((reg: IHostCallRegisters) => Gas);
 
   /** Currently executing service id. */
   readonly currentServiceId: U32;
@@ -17634,7 +18308,7 @@ declare class HostCalls {
       const maybeAddress = regs.getLowerU32(7);
       const maybeLength = regs.getLowerU32(8);
 
-      const result = new Uint8Array(maybeLength);
+      const result = safeAllocUint8Array(maybeLength);
       const startAddress = tryAsMemoryIndex(maybeAddress);
       const loadResult = memory.loadInto(result, startAddress);
 
@@ -17667,8 +18341,10 @@ declare class HostCalls {
 
       const hostCall = this.hostCalls.get(index);
       const gasBefore = gas.get();
-      const gasCost = typeof hostCall.gasCost === "number" ? hostCall.gasCost : hostCall.gasCost(regs);
-      const underflow = gas.sub(gasCost);
+      // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
+      const basicGasCost =
+        typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
+      const underflow = gas.sub(basicGasCost);
 
       const pcLog = `[PC: ${pvmInstance.getPC()}]`;
       if (underflow) {
@@ -17695,6 +18371,11 @@ declare class HostCalls {
         return this.getReturnValue(status, pvmInstance);
       }
 
+      if (result === PvmExecution.OOG) {
+        status = Status.OOG;
+        return this.getReturnValue(status, pvmInstance);
+      }
+
       if (result === undefined) {
         pvmInstance.runProgram();
         status = pvmInstance.getStatus();
@@ -18066,7 +18747,7 @@ declare class DebuggerAdapter {
 
     if (page === null) {
       // page wasn't allocated so we return an empty page
-      return new Uint8Array(PAGE_SIZE);
+      return safeAllocUint8Array(PAGE_SIZE);
     }
 
     if (page.length === PAGE_SIZE) {
@@ -18075,7 +18756,7 @@ declare class DebuggerAdapter {
     }
 
     // page was allocated but it is shorter than PAGE_SIZE so we have to extend it
-    const fullPage = new Uint8Array(PAGE_SIZE);
+    const fullPage = safeAllocUint8Array(PAGE_SIZE);
     fullPage.set(page);
     return fullPage;
   }
@@ -18256,7 +18937,7 @@ declare const index$3_tryAsMachineId: typeof tryAsMachineId;
 declare const index$3_tryAsProgramCounter: typeof tryAsProgramCounter;
 declare const index$3_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$3 {
-  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$j as block, index$q as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$n as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$p as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$l as block, index$s as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$p as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$r as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
   export type { index$3_Args as Args, index$3_EnumMapping as EnumMapping, index$3_ErrorResult as ErrorResult, index$3_IHostCallMemory as IHostCallMemory, index$3_IHostCallRegisters as IHostCallRegisters, index$3_InsufficientFundsError as InsufficientFundsError, index$3_MachineId as MachineId, index$3_MachineResult as MachineResult, index$3_MachineStatus as MachineStatus, index$3_NoMachineError as NoMachineError, index$3_OK as OK, index$3_OkResult as OkResult, index$3_Opaque as Opaque, index$3_PartialState as PartialState, index$3_PreimageStatus as PreimageStatus, index$3_ProgramCounter as ProgramCounter, index$3_RefineExternalities as RefineExternalities, index$3_SegmentExportError as SegmentExportError, index$3_ServiceStateUpdate as ServiceStateUpdate, index$3_StateSlice as StateSlice, index$3_StringLiteral as StringLiteral, index$3_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$3_TaggedError as TaggedError, index$3_TokenOf as TokenOf, index$3_Uninstantiable as Uninstantiable, index$3_UnprivilegedError as UnprivilegedError, index$3_WithOpaque as WithOpaque };
 }
 
@@ -18268,10 +18949,10 @@ type ENTROPY_BYTES = typeof ENTROPY_BYTES;
  *
  * https://graypaper.fluffylabs.dev/#/579bd12/3b9a013b9a01
  */
-declare function fisherYatesShuffle<T>(arr: T[], entropy: Bytes<ENTROPY_BYTES>): T[] {
+declare function fisherYatesShuffle<T>(blake2b: Blake2b, arr: T[], entropy: Bytes<ENTROPY_BYTES>): T[] {
   check`${entropy.length === ENTROPY_BYTES} Expected entropy of length ${ENTROPY_BYTES}, got ${entropy.length}`;
   const n = arr.length;
-  const randomNumbers = hashToNumberSequence(entropy, arr.length);
+  const randomNumbers = hashToNumberSequence(blake2b, entropy, arr.length);
   const result: T[] = new Array<T>(n);
 
   let itemsLeft = n;
@@ -18297,6 +18978,7 @@ declare namespace index$2 {
 declare class JsonServiceInfo {
   static fromJson = json.object<JsonServiceInfo, ServiceAccountInfo>(
     {
+      ...(Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? { version: "number" } : {}),
       code_hash: fromJson.bytes32(),
       balance: json.fromNumber((x) => tryAsU64(x)),
       min_item_gas: json.fromNumber((x) => tryAsServiceGas(x)),
@@ -18335,6 +19017,7 @@ declare class JsonServiceInfo {
     },
   );
 
+  version?: number;
   code_hash!: CodeHash;
   balance!: U64;
   min_item_gas!: ServiceGas;
@@ -18381,6 +19064,19 @@ declare const lookupMetaFromJson = json.object<JsonLookupMeta, LookupHistoryItem
   ({ key, value }) => new LookupHistoryItem(key.hash, key.length, value),
 );
 
+declare const preimageStatusFromJson = json.object<JsonPreimageStatus, LookupHistoryItem>(
+  {
+    hash: fromJson.bytes32(),
+    status: json.array("number"),
+  },
+  ({ hash, status }) => new LookupHistoryItem(hash, tryAsU32(0), status),
+);
+
+type JsonPreimageStatus = {
+  hash: PreimageHash;
+  status: LookupHistorySlots;
+};
+
 type JsonLookupMeta = {
   key: {
     hash: PreimageHash;
@@ -18393,21 +19089,34 @@ declare class JsonService {
   static fromJson = json.object<JsonService, InMemoryService>(
     {
       id: "number",
-      data: {
-        service: JsonServiceInfo.fromJson,
-        preimages: json.optional(json.array(JsonPreimageItem.fromJson)),
-        storage: json.optional(json.array(JsonStorageItem.fromJson)),
-        lookup_meta: json.optional(json.array(lookupMetaFromJson)),
-      },
+      data: Compatibility.isLessThan(GpVersion.V0_7_1)
+        ? {
+            service: JsonServiceInfo.fromJson,
+            preimages: json.optional(json.array(JsonPreimageItem.fromJson)),
+            storage: json.optional(json.array(JsonStorageItem.fromJson)),
+            lookup_meta: json.optional(json.array(lookupMetaFromJson)),
+          }
+        : {
+            service: JsonServiceInfo.fromJson,
+            storage: json.optional(json.array(JsonStorageItem.fromJson)),
+            preimages_blob: json.optional(json.array(JsonPreimageItem.fromJson)),
+            preimages_status: json.optional(json.array(preimageStatusFromJson)),
+          },
     },
     ({ id, data }) => {
+      const preimages = HashDictionary.fromEntries(
+        (data.preimages ?? data.preimages_blob ?? []).map((x) => [x.hash, x]),
+      );
+
       const lookupHistory = HashDictionary.new<PreimageHash, LookupHistoryItem[]>();
-      for (const item of data.lookup_meta ?? []) {
+
+      for (const item of data.lookup_meta ?? data.preimages_status ?? []) {
         const data = lookupHistory.get(item.hash) ?? [];
-        data.push(item);
+        const length = tryAsU32(preimages.get(item.hash)?.blob.length ?? item.length);
+        data.push(new LookupHistoryItem(item.hash, length, item.slots));
         lookupHistory.set(item.hash, data);
       }
-      const preimages = HashDictionary.fromEntries((data.preimages ?? []).map((x) => [x.hash, x]));
+
       const storage = new Map<string, StorageItem>();
 
       const entries = (data.storage ?? []).map(({ key, value }) => {
@@ -18434,6 +19143,8 @@ declare class JsonService {
     preimages?: JsonPreimageItem[];
     storage?: JsonStorageItem[];
     lookup_meta?: LookupHistoryItem[];
+    preimages_blob?: JsonPreimageItem[];
+    preimages_status?: LookupHistoryItem[];
   };
 }
 
@@ -18443,8 +19154,7 @@ declare const availabilityAssignmentFromJson = json.object<JsonAvailabilityAssig
     timeout: "number",
   },
   ({ report, timeout }) => {
-    const workReportHash = blake2b.hashBytes(Encoder.encodeObject(WorkReport.Codec, report)).asOpaque();
-    return AvailabilityAssignment.create({ workReport: new WithHash(workReportHash, report), timeout });
+    return AvailabilityAssignment.create({ workReport: report, timeout });
   },
 );
 
@@ -18665,8 +19375,12 @@ declare class JsonServiceStatistics {
       extrinsic_count: "number",
       accumulate_count: "number",
       accumulate_gas_used: json.fromNumber(tryAsServiceGas),
-      on_transfers_count: "number",
-      on_transfers_gas_used: json.fromNumber(tryAsServiceGas),
+      ...(Compatibility.isLessThan(GpVersion.V0_7_1)
+        ? {
+            on_transfers_count: "number",
+            on_transfers_gas_used: json.fromNumber(tryAsServiceGas),
+          }
+        : {}),
     },
     ({
       provided_count,
@@ -18693,8 +19407,8 @@ declare class JsonServiceStatistics {
         extrinsicCount: extrinsic_count,
         accumulateCount: accumulate_count,
         accumulateGasUsed: accumulate_gas_used,
-        onTransfersCount: on_transfers_count,
-        onTransfersGasUsed: on_transfers_gas_used,
+        onTransfersCount: on_transfers_count ?? tryAsU32(0),
+        onTransfersGasUsed: on_transfers_gas_used ?? tryAsServiceGas(0),
       });
     },
   );
@@ -18709,8 +19423,8 @@ declare class JsonServiceStatistics {
   extrinsic_count!: U16;
   accumulate_count!: U32;
   accumulate_gas_used!: ServiceGas;
-  on_transfers_count!: U32;
-  on_transfers_gas_used!: ServiceGas;
+  on_transfers_count?: U32;
+  on_transfers_gas_used?: ServiceGas;
 }
 
 type ServiceStatisticsEntry = {
@@ -18782,8 +19496,9 @@ type JsonStateDump = {
   tau: State["timeslot"];
   chi: {
     chi_m: PrivilegedServices["manager"];
-    chi_a: PrivilegedServices["authManager"];
-    chi_v: PrivilegedServices["validatorsManager"];
+    chi_a: PrivilegedServices["assigners"];
+    chi_v: PrivilegedServices["delegator"];
+    chi_r?: PrivilegedServices["registrar"];
     chi_g: PrivilegedServices["autoAccumulateServices"] | null;
   };
   pi: JsonStatisticsData;
@@ -18816,6 +19531,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
         chi_m: "number",
         chi_a: json.array("number"),
         chi_v: "number",
+        chi_r: json.optional("number"),
         chi_g: json.nullable(
           json.array({
             service: "number",
@@ -18848,6 +19564,9 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
       theta,
       accounts,
     }): InMemoryState => {
+      if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) && chi.chi_r === undefined) {
+        throw new Error("Registrar is required in Privileges GP ^0.7.1");
+      }
       return InMemoryState.create({
         authPools: tryAsPerCore(
           alpha.map((perCore) => {
@@ -18881,8 +19600,9 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
         timeslot: tau,
         privilegedServices: PrivilegedServices.create({
           manager: chi.chi_m,
-          authManager: chi.chi_a,
-          validatorsManager: chi.chi_v,
+          assigners: chi.chi_a,
+          delegator: chi.chi_v,
+          registrar: chi.chi_r ?? tryAsServiceId(2 ** 32 - 1),
           autoAccumulateServices: chi.chi_g ?? [],
         }),
         statistics: JsonStatisticsData.toStatisticsData(spec, pi),
@@ -18905,6 +19625,7 @@ declare const index$1_JsonDisputesRecords: typeof JsonDisputesRecords;
 type index$1_JsonLookupMeta = JsonLookupMeta;
 type index$1_JsonPreimageItem = JsonPreimageItem;
 declare const index$1_JsonPreimageItem: typeof JsonPreimageItem;
+type index$1_JsonPreimageStatus = JsonPreimageStatus;
 type index$1_JsonRecentBlockState = JsonRecentBlockState;
 type index$1_JsonRecentBlocks = JsonRecentBlocks;
 type index$1_JsonReportedWorkPackageInfo = JsonReportedWorkPackageInfo;
@@ -18929,6 +19650,7 @@ declare const index$1_disputesRecordsFromJson: typeof disputesRecordsFromJson;
 declare const index$1_fullStateDumpFromJson: typeof fullStateDumpFromJson;
 declare const index$1_lookupMetaFromJson: typeof lookupMetaFromJson;
 declare const index$1_notYetAccumulatedFromJson: typeof notYetAccumulatedFromJson;
+declare const index$1_preimageStatusFromJson: typeof preimageStatusFromJson;
 declare const index$1_recentBlockStateFromJson: typeof recentBlockStateFromJson;
 declare const index$1_recentBlocksHistoryFromJson: typeof recentBlocksHistoryFromJson;
 declare const index$1_reportedWorkPackageFromJson: typeof reportedWorkPackageFromJson;
@@ -18936,8 +19658,8 @@ declare const index$1_serviceStatisticsEntryFromJson: typeof serviceStatisticsEn
 declare const index$1_ticketFromJson: typeof ticketFromJson;
 declare const index$1_validatorDataFromJson: typeof validatorDataFromJson;
 declare namespace index$1 {
-  export { index$1_JsonCoreStatistics as JsonCoreStatistics, index$1_JsonDisputesRecords as JsonDisputesRecords, index$1_JsonPreimageItem as JsonPreimageItem, index$1_JsonService as JsonService, index$1_JsonServiceInfo as JsonServiceInfo, index$1_JsonServiceStatistics as JsonServiceStatistics, index$1_JsonStatisticsData as JsonStatisticsData, index$1_JsonStorageItem as JsonStorageItem, index$1_JsonValidatorStatistics as JsonValidatorStatistics, index$1_TicketsOrKeys as TicketsOrKeys, index$1_availabilityAssignmentFromJson as availabilityAssignmentFromJson, index$1_disputesRecordsFromJson as disputesRecordsFromJson, index$1_fullStateDumpFromJson as fullStateDumpFromJson, index$1_lookupMetaFromJson as lookupMetaFromJson, index$1_notYetAccumulatedFromJson as notYetAccumulatedFromJson, index$1_recentBlockStateFromJson as recentBlockStateFromJson, index$1_recentBlocksHistoryFromJson as recentBlocksHistoryFromJson, index$1_reportedWorkPackageFromJson as reportedWorkPackageFromJson, index$1_serviceStatisticsEntryFromJson as serviceStatisticsEntryFromJson, index$1_ticketFromJson as ticketFromJson, index$1_validatorDataFromJson as validatorDataFromJson };
-  export type { index$1_JsonAvailabilityAssignment as JsonAvailabilityAssignment, index$1_JsonLookupMeta as JsonLookupMeta, index$1_JsonRecentBlockState as JsonRecentBlockState, index$1_JsonRecentBlocks as JsonRecentBlocks, index$1_JsonReportedWorkPackageInfo as JsonReportedWorkPackageInfo, index$1_JsonStateDump as JsonStateDump, index$1_ServiceStatisticsEntry as ServiceStatisticsEntry };
+  export { index$1_JsonCoreStatistics as JsonCoreStatistics, index$1_JsonDisputesRecords as JsonDisputesRecords, index$1_JsonPreimageItem as JsonPreimageItem, index$1_JsonService as JsonService, index$1_JsonServiceInfo as JsonServiceInfo, index$1_JsonServiceStatistics as JsonServiceStatistics, index$1_JsonStatisticsData as JsonStatisticsData, index$1_JsonStorageItem as JsonStorageItem, index$1_JsonValidatorStatistics as JsonValidatorStatistics, index$1_TicketsOrKeys as TicketsOrKeys, index$1_availabilityAssignmentFromJson as availabilityAssignmentFromJson, index$1_disputesRecordsFromJson as disputesRecordsFromJson, index$1_fullStateDumpFromJson as fullStateDumpFromJson, index$1_lookupMetaFromJson as lookupMetaFromJson, index$1_notYetAccumulatedFromJson as notYetAccumulatedFromJson, index$1_preimageStatusFromJson as preimageStatusFromJson, index$1_recentBlockStateFromJson as recentBlockStateFromJson, index$1_recentBlocksHistoryFromJson as recentBlocksHistoryFromJson, index$1_reportedWorkPackageFromJson as reportedWorkPackageFromJson, index$1_serviceStatisticsEntryFromJson as serviceStatisticsEntryFromJson, index$1_ticketFromJson as ticketFromJson, index$1_validatorDataFromJson as validatorDataFromJson };
+  export type { index$1_JsonAvailabilityAssignment as JsonAvailabilityAssignment, index$1_JsonLookupMeta as JsonLookupMeta, index$1_JsonPreimageStatus as JsonPreimageStatus, index$1_JsonRecentBlockState as JsonRecentBlockState, index$1_JsonRecentBlocks as JsonRecentBlocks, index$1_JsonReportedWorkPackageInfo as JsonReportedWorkPackageInfo, index$1_JsonStateDump as JsonStateDump, index$1_ServiceStatisticsEntry as ServiceStatisticsEntry };
 }
 
 /** Helper function to create most used hashes in the block */
@@ -18945,7 +19667,7 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
   constructor(
     private readonly context: ChainSpec,
     private readonly keccakHasher: KeccakHasher,
-    private readonly allocator: HashAllocator,
+    public readonly blake2b: Blake2b,
   ) {}
 
   /** Concatenates two hashes and hash this concatenation */
@@ -18959,7 +19681,7 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
 
   /** Creates hash from the block header view */
   header(header: HeaderView): WithHash<HeaderHash, HeaderView> {
-    return new WithHash(blake2b.hashBytes(header.encoded(), this.allocator).asOpaque(), header);
+    return new WithHash(this.blake2b.hashBytes(header.encoded()).asOpaque(), header);
   }
 
   /**
@@ -18973,7 +19695,7 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
       .view()
       .map((g) => g.view())
       .map((guarantee) => {
-        const reportHash = blake2b.hashBytes(guarantee.report.encoded(), this.allocator).asOpaque<WorkReportHash>();
+        const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque<WorkReportHash>();
         return BytesBlob.blobFromParts([
           reportHash.raw,
           guarantee.slot.encoded().raw,
@@ -18983,15 +19705,15 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
 
     const guaranteeBlob = Encoder.encodeObject(codec.sequenceVarLen(dumpCodec), guarantees, this.context);
 
-    const et = blake2b.hashBytes(extrinsicView.tickets.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
-    const ep = blake2b.hashBytes(extrinsicView.preimages.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
-    const eg = blake2b.hashBytes(guaranteeBlob, this.allocator).asOpaque<ExtrinsicHash>();
-    const ea = blake2b.hashBytes(extrinsicView.assurances.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
-    const ed = blake2b.hashBytes(extrinsicView.disputes.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
+    const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque<ExtrinsicHash>();
+    const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque<ExtrinsicHash>();
+    const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque<ExtrinsicHash>();
+    const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque<ExtrinsicHash>();
+    const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque<ExtrinsicHash>();
 
     const encoded = BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);
 
-    return new WithHashAndBytes(blake2b.hashBytes(encoded, this.allocator).asOpaque(), extrinsicView, encoded);
+    return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), extrinsicView, encoded);
   }
 
   /** Creates hash for given WorkPackage */
@@ -19002,7 +19724,7 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
   private encode<T, THash extends OpaqueHash>(codec: Codec<T>, data: T): WithHashAndBytes<THash, T> {
     // TODO [ToDr] Use already allocated encoding destination and hash bytes from some arena.
     const encoded = Encoder.encodeObject(codec, data, this.context);
-    return new WithHashAndBytes(blake2b.hashBytes(encoded, this.allocator).asOpaque(), data, encoded);
+    return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), data, encoded);
   }
 }
 
@@ -19023,7 +19745,10 @@ declare enum PreimagesErrorCode {
 
 // TODO [SeKo] consider whether this module is the right place to remove expired preimages
 declare class Preimages {
-  constructor(public readonly state: PreimagesState) {}
+  constructor(
+    public readonly state: PreimagesState,
+    public readonly blake2b: Blake2b,
+  ) {}
 
   integrate(input: PreimagesInput): Result$2<PreimagesStateUpdate, PreimagesErrorCode> {
     // make sure lookup extrinsics are sorted and unique
@@ -19052,7 +19777,7 @@ declare class Preimages {
     // select preimages for integration
     for (const preimage of preimages) {
       const { requester, blob } = preimage;
-      const hash: PreimageHash = blake2b.hashBytes(blob).asOpaque();
+      const hash: PreimageHash = this.blake2b.hashBytes(blob).asOpaque();
 
       const service = this.state.getService(requester);
       if (service === null) {
@@ -19083,156 +19808,6 @@ declare class Preimages {
   }
 }
 
-declare enum ServiceExecutorError {
-  NoLookup = 0,
-  NoState = 1,
-  NoServiceCode = 2,
-  ServiceCodeMismatch = 3,
-}
-
-declare class WorkPackageExecutor {
-  constructor(
-    private readonly blocks: BlocksDb,
-    private readonly state: StatesDb,
-    private readonly hasher: TransitionHasher,
-  ) {}
-
-  // TODO [ToDr] this while thing should be triple-checked with the GP.
-  // I'm currently implementing some dirty version for the demo.
-  async executeWorkPackage(pack: WorkPackage): Promise<WorkReport> {
-    const headerHash = pack.context.lookupAnchor;
-    // execute authorisation first or is it already executed and we just need to check it?
-    const authExec = this.getServiceExecutor(
-      // TODO [ToDr] should this be anchor or lookupAnchor?
-      headerHash,
-      pack.authCodeHost,
-      pack.authCodeHash,
-    );
-
-    if (authExec.isError) {
-      // TODO [ToDr] most likely shouldn't be throw.
-      throw new Error(`Could not get authorization executor: ${authExec.error}`);
-    }
-
-    const pvm = authExec.ok;
-    const authGas = tryAsGas(15_000n);
-    const result = await pvm.run(pack.parametrization, authGas);
-
-    if (!result.isEqualTo(pack.authorization)) {
-      throw new Error("Authorization is invalid.");
-    }
-
-    const results: WorkResult[] = [];
-    for (const item of pack.items) {
-      const exec = this.getServiceExecutor(headerHash, item.service, item.codeHash);
-      if (exec.isError) {
-        throw new Error(`Could not get item executor: ${exec.error}`);
-      }
-      const pvm = exec.ok;
-
-      const gasRatio = tryAsServiceGas(3_000n);
-      const ret = await pvm.run(item.payload, tryAsGas(item.refineGasLimit)); // or accumulateGasLimit?
-      results.push(
-        WorkResult.create({
-          serviceId: item.service,
-          codeHash: item.codeHash,
-          payloadHash: blake2b.hashBytes(item.payload),
-          gas: gasRatio,
-          result: new WorkExecResult(WorkExecResultKind.ok, ret),
-          load: WorkRefineLoad.create({
-            gasUsed: tryAsServiceGas(5),
-            importedSegments: tryAsU32(0),
-            exportedSegments: tryAsU32(0),
-            extrinsicSize: tryAsU32(0),
-            extrinsicCount: tryAsU32(0),
-          }),
-        }),
-      );
-    }
-
-    const workPackage = this.hasher.workPackage(pack);
-    const workPackageSpec = WorkPackageSpec.create({
-      hash: workPackage.hash,
-      length: tryAsU32(workPackage.encoded.length),
-      erasureRoot: Bytes.zero(HASH_SIZE),
-      exportsRoot: Bytes.zero(HASH_SIZE).asOpaque(),
-      exportsCount: tryAsU16(0),
-    });
-    const coreIndex = tryAsCoreIndex(0);
-    const authorizerHash = Bytes.fill(HASH_SIZE, 5).asOpaque();
-
-    const workResults = FixedSizeArray.new(results, tryAsWorkItemsCount(results.length));
-
-    return Promise.resolve(
-      WorkReport.create({
-        workPackageSpec,
-        context: pack.context,
-        coreIndex,
-        authorizerHash,
-        authorizationOutput: pack.authorization,
-        segmentRootLookup: [],
-        results: workResults,
-        authorizationGasUsed: tryAsServiceGas(0),
-      }),
-    );
-  }
-
-  getServiceExecutor(
-    lookupAnchor: HeaderHash,
-    serviceId: ServiceId,
-    expectedCodeHash: CodeHash,
-  ): Result$2<PvmExecutor, ServiceExecutorError> {
-    const header = this.blocks.getHeader(lookupAnchor);
-    if (header === null) {
-      return Result.error(ServiceExecutorError.NoLookup);
-    }
-
-    const state = this.state.getState(lookupAnchor);
-    if (state === null) {
-      return Result.error(ServiceExecutorError.NoState);
-    }
-
-    const service = state.getService(serviceId);
-    const serviceCodeHash = service?.getInfo().codeHash ?? null;
-    if (serviceCodeHash === null) {
-      return Result.error(ServiceExecutorError.NoServiceCode);
-    }
-
-    if (!serviceCodeHash.isEqualTo(expectedCodeHash)) {
-      return Result.error(ServiceExecutorError.ServiceCodeMismatch);
-    }
-
-    const serviceCode = service?.getPreimage(serviceCodeHash.asOpaque()) ?? null;
-    if (serviceCode === null) {
-      return Result.error(ServiceExecutorError.NoServiceCode);
-    }
-
-    return Result.ok(new PvmExecutor(serviceCode));
-  }
-}
-
-declare class PvmExecutor {
-  private readonly pvm: HostCalls;
-  private hostCalls = new HostCallsManager({ missing: new Missing() });
-  private pvmInstanceManager = new PvmInstanceManager(4);
-
-  constructor(private serviceCode: BytesBlob) {
-    this.pvm = new PvmHostCallExtension(this.pvmInstanceManager, this.hostCalls);
-  }
-
-  async run(args: BytesBlob, gas: Gas): Promise<BytesBlob> {
-    const program = Program.fromSpi(this.serviceCode.raw, args.raw, true);
-
-    const result = await this.pvm.runProgram(program.code, 5, gas, program.registers, program.memory);
-
-    if (result.hasMemorySlice()) {
-      return BytesBlob.blobFrom(result.memorySlice);
-    }
-
-    return BytesBlob.empty();
-  }
-}
-
 type index_Preimages = Preimages;
 declare const index_Preimages: typeof Preimages;
 type index_PreimagesErrorCode = PreimagesErrorCode;
@@ -19242,11 +19817,9 @@ type index_PreimagesState = PreimagesState;
 type index_PreimagesStateUpdate = PreimagesStateUpdate;
 type index_TransitionHasher = TransitionHasher;
 declare const index_TransitionHasher: typeof TransitionHasher;
-type index_WorkPackageExecutor = WorkPackageExecutor;
-declare const index_WorkPackageExecutor: typeof WorkPackageExecutor;
 declare namespace index {
-  export { index_Preimages as Preimages, index_PreimagesErrorCode as PreimagesErrorCode, index_TransitionHasher as TransitionHasher, index_WorkPackageExecutor as WorkPackageExecutor };
+  export { index_Preimages as Preimages, index_PreimagesErrorCode as PreimagesErrorCode, index_TransitionHasher as TransitionHasher };
   export type { index_PreimagesInput as PreimagesInput, index_PreimagesState as PreimagesState, index_PreimagesStateUpdate as PreimagesStateUpdate };
 }
 
-export { index$j as block, index$h as block_json, index$q as bytes, index$o as codec, index$m as collections, index$k as config, index$f as config_node, index$l as crypto, index$a as database, index$9 as erasure_coding, index$n as hash, index$6 as jam_host_calls, index$i as json_parser, index$g as logger, index$d as mmr, index$p as numbers, index$r as ordering, index$3 as pvm, index$7 as pvm_host_calls, index$8 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$c as state, index$1 as state_json, index$b as state_merkleization, index as transition, index$e as trie, index$s as utils };
+export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$o as collections, index$m as config, index$h as config_node, index$n as crypto, index$c as database, index$b as erasure_coding, index$9 as fuzz_proto, index$p as hash, index$6 as jam_host_calls, index$k as json_parser, index$i as logger, index$f as mmr, index$r as numbers, index$t as ordering, index$3 as pvm, index$7 as pvm_host_calls, index$8 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$e as state, index$1 as state_json, index$d as state_merkleization, index as transition, index$g as trie, index$u as utils };