@typeberry/lib 0.1.3-3f7b9cf → 0.1.3-62eb49b

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;
         });
     };
@@ -755,11 +775,12 @@ 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, Result$2 as Result, index$u_RichTaggedError as RichTaggedError, index$u_TEST_COMPARE_USING as TEST_COMPARE_USING, index$u_TestSuite as TestSuite, index$u_WithDebug as WithDebug, index$u___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$u_asOpaqueType as asOpaqueType, index$u_assertEmpty as assertEmpty, index$u_assertNever as assertNever, index$u_callCompareFunction as callCompareFunction, index$u_check as check, index$u_deepEqual as deepEqual, index$u_getAllKeysSorted as getAllKeysSorted, index$u_inspect as inspect, index$u_isBrowser as isBrowser, index$u_isResult as isResult, index$u_isTaggedError as isTaggedError, index$u_maybeTaggedErrorToString as maybeTaggedErrorToString, index$u_measure as measure, index$u_oomWarningPrinted as oomWarningPrinted, index$u_parseCurrentSuite as parseCurrentSuite, index$u_parseCurrentVersion as parseCurrentVersion, index$u_resultToString as resultToString, index$u_seeThrough as seeThrough, index$u_trimStack as trimStack, index$u_workspacePathFix as workspacePathFix };
+  export { 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 };
 }
 
@@ -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);
   }
 
@@ -3461,6 +3482,99 @@ declare namespace index$q {
   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.
  *
@@ -3516,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);
-  }
-}
-
-/** 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();
-  }
+declare const zero$1 = Bytes.zero(HASH_SIZE);
 
-  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));
@@ -3681,15 +3697,15 @@ declare namespace keccak {
   };
 }
 
+// TODO [ToDr] (#213) this should most likely be moved to a separate
+// package to avoid pulling in unnecessary deps.
+
+type index$p_Blake2b = Blake2b;
+declare const index$p_Blake2b: typeof Blake2b;
 type index$p_Blake2bHash = Blake2bHash;
 type index$p_HASH_SIZE = HASH_SIZE;
-type index$p_HashAllocator = HashAllocator;
 type index$p_KeccakHash = KeccakHash;
 type index$p_OpaqueHash = OpaqueHash;
-type index$p_PageAllocator = PageAllocator;
-declare const index$p_PageAllocator: typeof PageAllocator;
-type index$p_SimpleAllocator = SimpleAllocator;
-declare const index$p_SimpleAllocator: typeof SimpleAllocator;
 type index$p_TRUNCATED_HASH_SIZE = TRUNCATED_HASH_SIZE;
 type index$p_TruncatedHash = TruncatedHash;
 type index$p_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
@@ -3697,12 +3713,10 @@ declare const index$p_WithHash: typeof WithHash;
 type index$p_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
 declare const index$p_WithHashAndBytes: typeof WithHashAndBytes;
 declare const index$p_ZERO_HASH: typeof ZERO_HASH;
-declare const index$p_blake2b: typeof blake2b;
-declare const index$p_defaultAllocator: typeof defaultAllocator;
 declare const index$p_keccak: typeof keccak;
 declare namespace index$p {
-  export { index$p_PageAllocator as PageAllocator, index$p_SimpleAllocator as SimpleAllocator, index$p_WithHash as WithHash, index$p_WithHashAndBytes as WithHashAndBytes, index$p_ZERO_HASH as ZERO_HASH, index$p_blake2b as blake2b, index$p_defaultAllocator as defaultAllocator, index$p_keccak as keccak };
-  export type { index$p_Blake2bHash as Blake2bHash, index$p_HASH_SIZE as HASH_SIZE, index$p_HashAllocator as HashAllocator, index$p_KeccakHash as KeccakHash, index$p_OpaqueHash as OpaqueHash, index$p_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$p_TruncatedHash as TruncatedHash };
+  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`. */
@@ -4479,6 +4493,8 @@ declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
   }
 }
 
+type index$o_ArrayView<T> = ArrayView<T>;
+declare const index$o_ArrayView: typeof ArrayView;
 type index$o_FixedSizeArray<T, N extends number> = FixedSizeArray<T, N>;
 declare const index$o_FixedSizeArray: typeof FixedSizeArray;
 type index$o_HashDictionary<K extends OpaqueHash, V> = HashDictionary<K, V>;
@@ -4506,7 +4522,7 @@ type index$o_TruncatedHashDictionary<T extends OpaqueHash, V> = TruncatedHashDic
 declare const index$o_TruncatedHashDictionary: typeof TruncatedHashDictionary;
 declare const index$o_asKnownSize: typeof asKnownSize;
 declare namespace index$o {
-  export { index$o_FixedSizeArray as FixedSizeArray, index$o_HashDictionary as HashDictionary, index$o_HashSet as HashSet, index$o_MultiMap as MultiMap, index$o_SortedArray as SortedArray, index$o_SortedSet as SortedSet, index$o_TruncatedHashDictionary as TruncatedHashDictionary, index$o_asKnownSize as asKnownSize };
+  export { 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 };
 }
 
@@ -4735,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;
 
@@ -4825,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();
 }
 
 /**
@@ -8373,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 */
@@ -9111,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.
  *
@@ -9136,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>(),
   });
 
@@ -9146,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,
   ) {
@@ -9250,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.
  *
@@ -9305,6 +9298,215 @@ declare class NotYetAccumulatedReport extends WithDebug {
   }
 }
 
+/**
+ * `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) => {},
+  );
+
+/** 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, {
@@ -9325,33 +9527,42 @@ declare class AutoAccumulate {
 }
 
 /**
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/11da0111da01?v=0.6.7
+ * 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>(),
-    authManager: codecPerCore(codec.u32.asOpaque<ServiceId>()),
-    validatorsManager: 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({ manager, authManager, validatorsManager, autoAccumulateServices }: CodecRecord<PrivilegedServices>) {
-    return new PrivilegedServices(manager, authManager, validatorsManager, autoAccumulateServices);
+  static create(a: CodecRecord<PrivilegedServices>) {
+    return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
   }
 
   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,
+     * `χ_M`: Manages 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
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
      */
     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. */
+    /** `χ_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[],
   ) {}
 }
@@ -9800,190 +10011,6 @@ declare class SafroleData {
   ) {}
 }
 
-/**
- * `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;
-  }
-}
-
 declare const codecServiceId: Descriptor<ServiceId> =
   Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
     ? codec.u32.asOpaque<ServiceId>()
@@ -11158,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, []),
@@ -11293,7 +11321,7 @@ declare const index$e_codecPerCore: typeof codecPerCore;
 declare const index$e_codecServiceId: typeof codecServiceId;
 declare const index$e_codecVarGas: typeof codecVarGas;
 declare const index$e_codecVarU16: typeof codecVarU16;
-declare const index$e_codecWithHash: typeof codecWithHash;
+declare const index$e_codecWithVersion: typeof codecWithVersion;
 declare const index$e_hashComparator: typeof hashComparator;
 declare const index$e_ignoreValueWithDefault: typeof ignoreValueWithDefault;
 declare const index$e_serviceDataCodec: typeof serviceDataCodec;
@@ -11304,7 +11332,7 @@ declare const index$e_tryAsPerCore: typeof tryAsPerCore;
 declare const index$e_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
 declare const index$e_zeroSizeHint: typeof zeroSizeHint;
 declare namespace index$e {
-  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_RecentBlocksHistory as RecentBlocksHistory, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithHash as codecWithHash, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export { 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 };
 }
 
@@ -11372,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);
@@ -11380,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);
@@ -11392,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);
@@ -11405,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);
@@ -11589,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)),
   });
 }
@@ -11641,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!)
@@ -11649,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);
 }
 
@@ -11663,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;
       }
@@ -11684,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,
@@ -11704,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;
       }
@@ -11725,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
@@ -11734,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)];
     }
   }
@@ -11868,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));
   }
 
   /**
@@ -11924,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));
@@ -11937,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>([]);
@@ -11969,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()));
       }
     }
@@ -12013,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[],
@@ -12058,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 {
@@ -12157,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,
@@ -12172,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;
   }
 
   /**
@@ -12189,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;
     }
@@ -12212,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);
 }
 
 /**
@@ -12370,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();
   }
 
@@ -12468,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. */
@@ -12573,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);
@@ -12629,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++) {
@@ -12649,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];
     }
@@ -12669,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++) {
@@ -12796,7 +12849,7 @@ 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++) {
@@ -13639,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 {
@@ -13704,14 +13759,18 @@ interface PartialState {
   ): 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 of that service.
-   * https://graypaper.fluffylabs.dev/#/7e6ff6a/2f4c022f4c02?v=0.6.7
+   * Returns a newly assigned id
+   * or `wantedServiceId` if it's lower than `S`
+   * and parent of that service is `Registrar`.
+   *
+   * 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,
@@ -13719,6 +13778,7 @@ interface PartialState {
     gas: ServiceGas,
     allowance: ServiceGas,
     gratisStorage: U64,
+    wantedServiceId: U64,
   ): Result$2<ServiceId, NewServiceError>;
 
   /** Upgrade code of currently running service. */
@@ -13740,7 +13800,7 @@ interface PartialState {
   updateAuthorizationQueue(
     coreIndex: CoreIndex,
     authQueue: FixedSizeArray<Blake2bHash, AUTHORIZATION_QUEUE_SIZE>,
-    authManager: ServiceId | null,
+    assigners: ServiceId | null,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /**
@@ -13749,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. */
@@ -13868,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)) {
@@ -14012,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);
@@ -17725,7 +17787,7 @@ 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;
@@ -17996,7 +18058,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
@@ -18004,7 +18066,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),
@@ -18239,7 +18301,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);
 
@@ -18678,7 +18740,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) {
@@ -18687,7 +18749,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;
   }
@@ -18880,10 +18942,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;
@@ -19055,8 +19117,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 });
   },
 );
 
@@ -19394,8 +19455,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;
@@ -19428,6 +19490,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",
@@ -19460,6 +19523,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) => {
@@ -19493,8 +19559,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),
@@ -19557,7 +19624,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 */
@@ -19571,7 +19638,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);
   }
 
   /**
@@ -19585,7 +19652,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,
@@ -19595,15 +19662,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 */
@@ -19614,7 +19681,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);
   }
 }
 
@@ -19635,7 +19702,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
@@ -19664,7 +19734,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) {
@@ -19695,156 +19765,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;
@@ -19854,10 +19774,8 @@ 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 };
 }