@typeberry/lib 0.1.3 → 0.2.0-f9e8db5

package/index.d.ts

@@ -1,7 +1,7 @@
 declare enum GpVersion {
   V0_6_7 = "0.6.7",
   V0_7_0 = "0.7.0",
-  V0_7_1 = "0.7.1-preview",
+  V0_7_1 = "0.7.1",
   V0_7_2 = "0.7.2-preview",
 }
 
@@ -11,12 +11,12 @@ declare enum TestSuite {
 }
 
 declare const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-
-declare const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
-declare const DEFAULT_VERSION = GpVersion.V0_7_0;
+declare const DEFAULT_VERSION = GpVersion.V0_7_1;
 declare let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 declare let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
 
+declare const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
+
 declare function parseCurrentVersion(env?: string): GpVersion | undefined {
   if (env === undefined) {
     return undefined;
@@ -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;
+declare const zero$1 = Bytes.zero(HASH_SIZE);
 
-  // TODO [ToDr] Benchmark the performance!
-  constructor(private readonly hashesPerPage: number) {
-    check`${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
-    this.resetPage();
+declare class Blake2b {
+  static async createHasher() {
+    return new Blake2b(await createBLAKE2b(HASH_SIZE * 8));
   }
 
-  private resetPage() {
-    const pageSizeBytes = this.hashesPerPage * HASH_SIZE;
-    this.currentHash = 0;
-    this.page = new Uint8Array(pageSizeBytes);
-  }
-
-  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,
   ) {
@@ -9196,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>,
@@ -9205,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,
@@ -9231,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.
  *
@@ -9286,57 +9298,275 @@ 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>(),
-  });
+/**
+ * `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;
 
-  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
-    return new AutoAccumulate(service, gasLimit);
-  }
+declare const zeroSizeHint: SizeHint = {
+  bytes: 0,
+  isExact: true,
+};
 
-  private constructor(
-    /** Service id that auto-accumulates. */
-    readonly service: ServiceId,
-    /** Gas limit for auto-accumulation. */
-    readonly gasLimit: ServiceGas,
-  ) {}
-}
+/** 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);
+    },
+  );
 
 /**
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/11da0111da01?v=0.6.7
+ * Service account details.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?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 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({ manager, authManager, validatorsManager, autoAccumulateServices }: CodecRecord<PrivilegedServices>) {
-    return new PrivilegedServices(manager, authManager, validatorsManager, 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,
-     * 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[],
-  ) {}
-}
-
+  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");
 
 /** Merkle Mountain Range peaks. */
@@ -9641,328 +9871,144 @@ declare class RecentBlocksHistory extends WithDebug {
 /**
  * Fixed size of validator metadata.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
- */
-declare const VALIDATOR_META_BYTES = 128;
-type VALIDATOR_META_BYTES = typeof VALIDATOR_META_BYTES;
-
-/**
- * Details about validators' identity.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
- */
-declare class ValidatorData extends WithDebug {
-  static Codec = codec.Class(ValidatorData, {
-    bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>(),
-    ed25519: codec.bytes(ED25519_KEY_BYTES).asOpaque<Ed25519Key>(),
-    bls: codec.bytes(BLS_KEY_BYTES).asOpaque<BlsKey>(),
-    metadata: codec.bytes(VALIDATOR_META_BYTES),
-  });
-
-  static create({ ed25519, bandersnatch, bls, metadata }: CodecRecord<ValidatorData>) {
-    return new ValidatorData(bandersnatch, ed25519, bls, metadata);
-  }
-
-  private constructor(
-    /** Bandersnatch public key. */
-    public readonly bandersnatch: BandersnatchKey,
-    /** ED25519 key data. */
-    public readonly ed25519: Ed25519Key,
-    /** BLS public key. */
-    public readonly bls: BlsKey,
-    /** Validator-defined additional metdata. */
-    public readonly metadata: Bytes<VALIDATOR_META_BYTES>,
-  ) {
-    super();
-  }
-}
-
-declare enum SafroleSealingKeysKind {
-  Tickets = 0,
-  Keys = 1,
-}
-
-type SafroleSealingKeys =
-  | {
-      kind: SafroleSealingKeysKind.Keys;
-      keys: PerEpochBlock<BandersnatchKey>;
-    }
-  | {
-      kind: SafroleSealingKeysKind.Tickets;
-      tickets: PerEpochBlock<Ticket>;
-    };
-
-declare const codecBandersnatchKey = codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>();
-
-declare class SafroleSealingKeysData extends WithDebug {
-  static Codec = codecWithContext((context) => {
-    return codec.custom<SafroleSealingKeys>(
-      {
-        name: "SafroleSealingKeys",
-        sizeHint: { bytes: 1 + HASH_SIZE * context.epochLength, isExact: false },
-      },
-      (e, x) => {
-        e.varU32(tryAsU32(x.kind));
-        if (x.kind === SafroleSealingKeysKind.Keys) {
-          e.sequenceFixLen(codecBandersnatchKey, x.keys);
-        } else {
-          e.sequenceFixLen(Ticket.Codec, x.tickets);
-        }
-      },
-      (d) => {
-        const epochLength = context.epochLength;
-        const kind = d.varU32();
-        if (kind === SafroleSealingKeysKind.Keys) {
-          const keys = d.sequenceFixLen<BandersnatchKey>(codecBandersnatchKey, epochLength);
-          return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
-        }
-
-        if (kind === SafroleSealingKeysKind.Tickets) {
-          const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
-          return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
-        }
-
-        throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-      },
-      (s) => {
-        const kind = s.decoder.varU32();
-        if (kind === SafroleSealingKeysKind.Keys) {
-          s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
-          return;
-        }
-        if (kind === SafroleSealingKeysKind.Tickets) {
-          s.sequenceFixLen(Ticket.Codec, context.epochLength);
-          return;
-        }
-
-        throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-      },
-    );
-  });
-
-  static keys(keys: PerEpochBlock<BandersnatchKey>): SafroleSealingKeys {
-    return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined) as SafroleSealingKeys;
-  }
-
-  static tickets(tickets: PerEpochBlock<Ticket>): SafroleSealingKeys {
-    return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets) as SafroleSealingKeys;
-  }
-
-  private constructor(
-    readonly kind: SafroleSealingKeysKind,
-    readonly keys?: PerEpochBlock<BandersnatchKey>,
-    readonly tickets?: PerEpochBlock<Ticket>,
-  ) {
-    super();
-  }
-}
-
-declare class SafroleData {
-  static Codec = codec.Class(SafroleData, {
-    nextValidatorData: codecPerValidator(ValidatorData.Codec),
-    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();
-  }
-}
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
+ */
+declare const VALIDATOR_META_BYTES = 128;
+type VALIDATOR_META_BYTES = typeof VALIDATOR_META_BYTES;
 
-declare class PreimageItem extends WithDebug {
-  static Codec = codec.Class(PreimageItem, {
-    hash: codec.bytes(HASH_SIZE).asOpaque<PreimageHash>(),
-    blob: codec.blob,
+/**
+ * Details about validators' identity.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
+ */
+declare class ValidatorData extends WithDebug {
+  static Codec = codec.Class(ValidatorData, {
+    bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>(),
+    ed25519: codec.bytes(ED25519_KEY_BYTES).asOpaque<Ed25519Key>(),
+    bls: codec.bytes(BLS_KEY_BYTES).asOpaque<BlsKey>(),
+    metadata: codec.bytes(VALIDATOR_META_BYTES),
   });
 
-  static create({ hash, blob }: CodecRecord<PreimageItem>) {
-    return new PreimageItem(hash, blob);
+  static create({ ed25519, bandersnatch, bls, metadata }: CodecRecord<ValidatorData>) {
+    return new ValidatorData(bandersnatch, ed25519, bls, metadata);
   }
 
   private constructor(
-    readonly hash: PreimageHash,
-    readonly blob: BytesBlob,
+    /** Bandersnatch public key. */
+    public readonly bandersnatch: BandersnatchKey,
+    /** ED25519 key data. */
+    public readonly ed25519: Ed25519Key,
+    /** BLS public key. */
+    public readonly bls: BlsKey,
+    /** Validator-defined additional metdata. */
+    public readonly metadata: Bytes<VALIDATOR_META_BYTES>,
   ) {
     super();
   }
 }
 
-type StorageKey = Opaque<BytesBlob, "storage key">;
+declare enum SafroleSealingKeysKind {
+  Tickets = 0,
+  Keys = 1,
+}
 
-declare class StorageItem extends WithDebug {
-  static Codec = codec.Class(StorageItem, {
-    key: codec.blob.convert(
-      (i) => i,
-      (o) => asOpaqueType(o),
-    ),
-    value: codec.blob,
+type SafroleSealingKeys =
+  | {
+      kind: SafroleSealingKeysKind.Keys;
+      keys: PerEpochBlock<BandersnatchKey>;
+    }
+  | {
+      kind: SafroleSealingKeysKind.Tickets;
+      tickets: PerEpochBlock<Ticket>;
+    };
+
+declare const codecBandersnatchKey = codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>();
+
+declare class SafroleSealingKeysData extends WithDebug {
+  static Codec = codecWithContext((context) => {
+    return codec.custom<SafroleSealingKeys>(
+      {
+        name: "SafroleSealingKeys",
+        sizeHint: { bytes: 1 + HASH_SIZE * context.epochLength, isExact: false },
+      },
+      (e, x) => {
+        e.varU32(tryAsU32(x.kind));
+        if (x.kind === SafroleSealingKeysKind.Keys) {
+          e.sequenceFixLen(codecBandersnatchKey, x.keys);
+        } else {
+          e.sequenceFixLen(Ticket.Codec, x.tickets);
+        }
+      },
+      (d) => {
+        const epochLength = context.epochLength;
+        const kind = d.varU32();
+        if (kind === SafroleSealingKeysKind.Keys) {
+          const keys = d.sequenceFixLen<BandersnatchKey>(codecBandersnatchKey, epochLength);
+          return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
+        }
+
+        if (kind === SafroleSealingKeysKind.Tickets) {
+          const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
+          return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
+        }
+
+        throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+      },
+      (s) => {
+        const kind = s.decoder.varU32();
+        if (kind === SafroleSealingKeysKind.Keys) {
+          s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
+          return;
+        }
+        if (kind === SafroleSealingKeysKind.Tickets) {
+          s.sequenceFixLen(Ticket.Codec, context.epochLength);
+          return;
+        }
+
+        throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+      },
+    );
   });
 
-  static create({ key, value }: CodecRecord<StorageItem>) {
-    return new StorageItem(key, value);
+  static keys(keys: PerEpochBlock<BandersnatchKey>): SafroleSealingKeys {
+    return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined) as SafroleSealingKeys;
+  }
+
+  static tickets(tickets: PerEpochBlock<Ticket>): SafroleSealingKeys {
+    return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets) as SafroleSealingKeys;
   }
 
   private constructor(
-    readonly key: StorageKey,
-    readonly value: BytesBlob,
+    readonly kind: SafroleSealingKeysKind,
+    readonly keys?: PerEpochBlock<BandersnatchKey>,
+    readonly tickets?: PerEpochBlock<Ticket>,
   ) {
     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.`);
+declare class SafroleData {
+  static Codec = codec.Class(SafroleData, {
+    nextValidatorData: codecPerValidator(ValidatorData.Codec),
+    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);
   }
-  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,
+  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">,
   ) {}
-
-  static isRequested(item: LookupHistoryItem | LookupHistorySlots): boolean {
-    if ("slots" in item) {
-      return item.slots.length === 0;
-    }
-    return item.length === 0;
-  }
 }
 
 declare const codecServiceId: Descriptor<ServiceId> =
@@ -10105,12 +10151,26 @@ declare class CoreStatistics {
  * Service statistics.
  * Updated per block, based on available work reports (`W`).
  *
- * https://graypaper.fluffylabs.dev/#/68eaa1f/185104185104?v=0.6.4
- * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L77
+ * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
  */
 declare class ServiceStatistics {
-  static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-    ? codec.Class(ServiceStatistics, {
+  static Codec = Compatibility.selectIfGreaterOrEqual({
+    fallback: codec.Class(ServiceStatistics, {
+      providedCount: codecVarU16,
+      providedSize: codec.varU32,
+      refinementCount: codec.varU32,
+      refinementGasUsed: codecVarGas,
+      imports: codecVarU16,
+      exports: codecVarU16,
+      extrinsicSize: codec.varU32,
+      extrinsicCount: codecVarU16,
+      accumulateCount: codec.varU32,
+      accumulateGasUsed: codecVarGas,
+      onTransfersCount: codec.varU32,
+      onTransfersGasUsed: codecVarGas,
+    }),
+    versions: {
+      [GpVersion.V0_7_0]: codec.Class(ServiceStatistics, {
         providedCount: codecVarU16,
         providedSize: codec.varU32,
         refinementCount: codec.varU32,
@@ -10123,21 +10183,23 @@ declare class ServiceStatistics {
         accumulateGasUsed: codecVarGas,
         onTransfersCount: codec.varU32,
         onTransfersGasUsed: codecVarGas,
-      })
-    : codec.Class(ServiceStatistics, {
+      }),
+      [GpVersion.V0_7_1]: codec.Class(ServiceStatistics, {
         providedCount: codecVarU16,
         providedSize: codec.varU32,
         refinementCount: codec.varU32,
         refinementGasUsed: codecVarGas,
         imports: codecVarU16,
-        exports: codecVarU16,
-        extrinsicSize: codec.varU32,
         extrinsicCount: codecVarU16,
+        extrinsicSize: codec.varU32,
+        exports: codecVarU16,
         accumulateCount: codec.varU32,
         accumulateGasUsed: codecVarGas,
-        onTransfersCount: codec.varU32,
-        onTransfersGasUsed: codecVarGas,
-      });
+        onTransfersCount: ignoreValueWithDefault(tryAsU32(0)),
+        onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
+      }),
+    },
+  });
 
   static create(v: CodecRecord<ServiceStatistics>) {
     return new ServiceStatistics(
@@ -10177,9 +10239,9 @@ declare class ServiceStatistics {
     public accumulateCount: U32,
     /** `a.1` */
     public accumulateGasUsed: ServiceGas,
-    /** `t.0` */
+    /** `t.0` @deprecated since 0.7.1 */
     public onTransfersCount: U32,
-    /** `t.1` */
+    /** `t.1` @deprecated since 0.7.1 */
     public onTransfersGasUsed: ServiceGas,
   ) {}
 
@@ -11139,8 +11201,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, []),
@@ -11274,7 +11337,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;
@@ -11285,7 +11348,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 };
 }
 
@@ -11353,7 +11416,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);
@@ -11361,11 +11424,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);
@@ -11373,11 +11436,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);
@@ -11386,11 +11454,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);
@@ -11570,24 +11638,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)),
   });
 }
@@ -11622,6 +11692,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!)
@@ -11630,9 +11701,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);
 }
 
@@ -11644,18 +11715,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;
       }
@@ -11665,16 +11736,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,
@@ -11685,16 +11760,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;
       }
@@ -11706,6 +11781,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
@@ -11715,7 +11791,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)];
     }
   }
@@ -11849,8 +11925,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));
   }
 
   /**
@@ -11905,7 +11981,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));
@@ -11918,6 +11995,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>([]);
@@ -11950,20 +12028,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()));
       }
     }
@@ -11994,21 +12077,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[],
@@ -12039,7 +12124,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 {
@@ -12138,6 +12223,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,
@@ -12153,14 +12239,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;
   }
 
   /**
@@ -12170,17 +12256,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;
     }
@@ -12193,9 +12279,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);
 }
 
 /**
@@ -12351,7 +12437,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();
   }
 
@@ -12449,7 +12536,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. */
@@ -12554,7 +12642,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);
@@ -12610,7 +12698,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++) {
@@ -12630,7 +12718,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];
     }
@@ -12650,7 +12738,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++) {
@@ -12777,7 +12865,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++) {
@@ -13620,6 +13708,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 {
@@ -13675,25 +13765,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,
@@ -13701,6 +13794,7 @@ interface PartialState {
     gas: ServiceGas,
     allowance: ServiceGas,
     gratisStorage: U64,
+    wantedServiceId: U64,
   ): Result$2<ServiceId, NewServiceError>;
 
   /** Upgrade code of currently running service. */
@@ -13722,7 +13816,7 @@ interface PartialState {
   updateAuthorizationQueue(
     coreIndex: CoreIndex,
     authQueue: FixedSizeArray<Blake2bHash, AUTHORIZATION_QUEUE_SIZE>,
-    authManager: ServiceId | null,
+    assigners: ServiceId | null,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /**
@@ -13731,14 +13825,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. */
@@ -13850,7 +13946,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)) {
@@ -13994,7 +14090,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);
@@ -17656,7 +17752,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(),
   ) {}
@@ -17707,11 +17803,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">;
@@ -17978,7 +18081,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
@@ -17986,7 +18089,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),
@@ -18052,9 +18155,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. */
@@ -18067,8 +18176,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;
@@ -18211,7 +18324,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);
 
@@ -18244,8 +18357,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) {
@@ -18272,6 +18387,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();
@@ -18643,7 +18763,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) {
@@ -18652,7 +18772,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;
   }
@@ -18845,10 +18965,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;
@@ -18874,6 +18994,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)),
@@ -18912,6 +19033,7 @@ declare class JsonServiceInfo {
     },
   );
 
+  version?: number;
   code_hash!: CodeHash;
   balance!: U64;
   min_item_gas!: ServiceGas;
@@ -18958,6 +19080,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;
@@ -18970,21 +19105,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 }) => {
@@ -19011,6 +19159,8 @@ declare class JsonService {
     preimages?: JsonPreimageItem[];
     storage?: JsonStorageItem[];
     lookup_meta?: LookupHistoryItem[];
+    preimages_blob?: JsonPreimageItem[];
+    preimages_status?: LookupHistoryItem[];
   };
 }
 
@@ -19020,8 +19170,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 });
   },
 );
 
@@ -19242,8 +19391,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,
@@ -19270,8 +19423,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),
       });
     },
   );
@@ -19286,8 +19439,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 = {
@@ -19359,8 +19512,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;
@@ -19393,6 +19547,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",
@@ -19425,6 +19580,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) => {
@@ -19458,8 +19616,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),
@@ -19482,6 +19641,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;
@@ -19506,6 +19666,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;
@@ -19513,8 +19674,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 */
@@ -19522,7 +19683,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 */
@@ -19536,7 +19697,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);
   }
 
   /**
@@ -19550,7 +19711,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,
@@ -19560,15 +19721,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 */
@@ -19579,7 +19740,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);
   }
 }
 
@@ -19600,7 +19761,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
@@ -19629,7 +19793,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) {
@@ -19660,156 +19824,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;
@@ -19819,10 +19833,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 };
 }