@typeberry/lib 0.1.3 → 0.2.0-e767e74

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);
   }
 
@@ -2406,11 +2427,15 @@ type ClassConstructor<T> = {
   create: (o: CodecRecord<T>) => T;
 };
 
-/**
- * A full codec type, i.e. the `Encode` and `Decode`.
- */
+/** A full codec type, i.e. the `Encode` and `Decode`. */
 type Codec<T> = Encode<T> & Decode<T>;
 
+/** A codec descriptor with extra view. */
+type CodecWithView<T, V> = Codec<T> & {
+  /** encoded data view codec. */
+  View: Codec<V>;
+};
+
 /**
  * Type descriptor definition.
  *
@@ -2419,7 +2444,7 @@ type Codec<T> = Encode<T> & Decode<T>;
  *
  * Descriptors can be composed to form more complex typings.
  */
-declare class Descriptor<T, V = T> implements Codec<T>, Skip {
+declare class Descriptor<T, V = T> implements Codec<T>, Skip, CodecWithView<T, V> {
   /** A "lightweight" version of the object. */
   public readonly View: Descriptor<V>;
 
@@ -2665,6 +2690,10 @@ declare abstract class ObjectView<T> {
   toString() {
     return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
   }
+
+  [TEST_COMPARE_USING]() {
+    return this.materialize();
+  }
 }
 
 /**
@@ -3216,15 +3245,25 @@ declare namespace codec$1 {
       sizeHint: SizeHint;
     },
     chooser: (ctx: unknown | null) => Descriptor<T, V>,
-  ): Descriptor<T, V> =>
-    Descriptor.withView(
+  ): Descriptor<T, V> => {
+    const Self = chooser(null);
+    return Descriptor.withView(
       name,
       sizeHint,
       (e, x) => chooser(e.getContext()).encode(e, x),
       (d) => chooser(d.getContext()).decode(d),
       (s) => chooser(s.decoder.getContext()).skip(s),
-      chooser(null).View,
+      hasUniqueView(Self)
+        ? select(
+            {
+              name: Self.View.name,
+              sizeHint: Self.View.sizeHint,
+            },
+            (ctx) => chooser(ctx).View,
+          )
+        : Self.View,
     );
+  };
 
   /**
    * A descriptor for a more complex POJO.
@@ -3418,6 +3457,7 @@ declare function sequenceViewFixLen<T, V>(
 type index$q_ClassConstructor<T> = ClassConstructor<T>;
 type index$q_Codec<T> = Codec<T>;
 type index$q_CodecRecord<T> = CodecRecord<T>;
+type index$q_CodecWithView<T, V> = CodecWithView<T, V>;
 declare const index$q_DEFAULT_START_LENGTH: typeof DEFAULT_START_LENGTH;
 type index$q_Decode<T> = Decode<T>;
 type index$q_Decoder = Decoder;
@@ -3458,9 +3498,102 @@ declare const index$q_tryAsExactBytes: typeof tryAsExactBytes;
 declare const index$q_validateLength: typeof validateLength;
 declare namespace index$q {
   export { index$q_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$q_Decoder as Decoder, index$q_Descriptor as Descriptor, index$q_Encoder as Encoder, index$q_MASKS as MASKS, index$q_MAX_LENGTH as MAX_LENGTH, index$q_ObjectView as ObjectView, index$q_SequenceView as SequenceView, index$q_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$q_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$q_ViewField as ViewField, index$q_addSizeHints as addSizeHints, codec$1 as codec, index$q_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$q_exactHint as exactHint, index$q_forEachDescriptor as forEachDescriptor, index$q_hasUniqueView as hasUniqueView, index$q_objectView as objectView, index$q_readonlyArray as readonlyArray, index$q_sequenceViewFixLen as sequenceViewFixLen, index$q_sequenceViewVarLen as sequenceViewVarLen, index$q_tryAsExactBytes as tryAsExactBytes, index$q_validateLength as validateLength };
-  export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
+  export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_CodecWithView as CodecWithView, 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 +3649,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 +3716,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 +3732,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 +4512,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 +4541,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 +4770,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 +4860,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();
 }
 
 /**
@@ -6907,6 +6936,17 @@ declare function emptyBlock(slot: TimeSlot = tryAsTimeSlot(0)) {
   });
 }
 
+/**
+ * Take an input data and re-encode that data as view.
+ *
+ * NOTE: this function should NEVER be used in any production code,
+ * it's only a test helper.
+ */
+declare function reencodeAsView<T, V>(codec: Descriptor<T, V>, object: T, chainSpec?: ChainSpec): V {
+  const encoded = Encoder.encodeObject(codec, object, chainSpec);
+  return Decoder.decodeObject(codec.View, encoded, chainSpec);
+}
+
 type index$l_Block = Block;
 declare const index$l_Block: typeof Block;
 type index$l_BlockView = BlockView;
@@ -6956,6 +6996,7 @@ declare const index$l_guarantees: typeof guarantees;
 declare const index$l_headerViewWithHashCodec: typeof headerViewWithHashCodec;
 declare const index$l_legacyDescriptor: typeof legacyDescriptor;
 declare const index$l_preimage: typeof preimage;
+declare const index$l_reencodeAsView: typeof reencodeAsView;
 declare const index$l_refineContext: typeof refineContext;
 declare const index$l_tickets: typeof tickets;
 declare const index$l_tryAsCoreIndex: typeof tryAsCoreIndex;
@@ -6972,7 +7013,7 @@ declare const index$l_workPackage: typeof workPackage;
 declare const index$l_workReport: typeof workReport;
 declare const index$l_workResult: typeof workResult;
 declare namespace index$l {
-  export { index$l_Block as Block, index$l_EpochMarker as EpochMarker, index$l_Extrinsic as Extrinsic, index$l_Header as Header, index$l_HeaderViewWithHash as HeaderViewWithHash, index$l_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$l_TicketsMarker as TicketsMarker, index$l_ValidatorKeys as ValidatorKeys, index$l_W_E as W_E, index$l_W_S as W_S, index$l_assurances as assurances, index$l_codecPerEpochBlock as codecPerEpochBlock, index$l_codecPerValidator as codecPerValidator, codec as codecUtils, index$l_disputes as disputes, index$l_emptyBlock as emptyBlock, index$l_encodeUnsealedHeader as encodeUnsealedHeader, index$l_guarantees as guarantees, index$l_headerViewWithHashCodec as headerViewWithHashCodec, index$l_legacyDescriptor as legacyDescriptor, index$l_preimage as preimage, index$l_refineContext as refineContext, index$l_tickets as tickets, index$l_tryAsCoreIndex as tryAsCoreIndex, index$l_tryAsEpoch as tryAsEpoch, index$l_tryAsPerEpochBlock as tryAsPerEpochBlock, index$l_tryAsPerValidator as tryAsPerValidator, index$l_tryAsSegmentIndex as tryAsSegmentIndex, index$l_tryAsServiceGas as tryAsServiceGas, index$l_tryAsServiceId as tryAsServiceId, index$l_tryAsTimeSlot as tryAsTimeSlot, index$l_tryAsValidatorIndex as tryAsValidatorIndex, index$l_workItem as workItem, index$l_workPackage as workPackage, index$l_workReport as workReport, index$l_workResult as workResult };
+  export { index$l_Block as Block, index$l_EpochMarker as EpochMarker, index$l_Extrinsic as Extrinsic, index$l_Header as Header, index$l_HeaderViewWithHash as HeaderViewWithHash, index$l_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$l_TicketsMarker as TicketsMarker, index$l_ValidatorKeys as ValidatorKeys, index$l_W_E as W_E, index$l_W_S as W_S, index$l_assurances as assurances, index$l_codecPerEpochBlock as codecPerEpochBlock, index$l_codecPerValidator as codecPerValidator, codec as codecUtils, index$l_disputes as disputes, index$l_emptyBlock as emptyBlock, index$l_encodeUnsealedHeader as encodeUnsealedHeader, index$l_guarantees as guarantees, index$l_headerViewWithHashCodec as headerViewWithHashCodec, index$l_legacyDescriptor as legacyDescriptor, index$l_preimage as preimage, index$l_reencodeAsView as reencodeAsView, index$l_refineContext as refineContext, index$l_tickets as tickets, index$l_tryAsCoreIndex as tryAsCoreIndex, index$l_tryAsEpoch as tryAsEpoch, index$l_tryAsPerEpochBlock as tryAsPerEpochBlock, index$l_tryAsPerValidator as tryAsPerValidator, index$l_tryAsSegmentIndex as tryAsSegmentIndex, index$l_tryAsServiceGas as tryAsServiceGas, index$l_tryAsServiceId as tryAsServiceId, index$l_tryAsTimeSlot as tryAsTimeSlot, index$l_tryAsValidatorIndex as tryAsValidatorIndex, index$l_workItem as workItem, index$l_workPackage as workPackage, index$l_workReport as workReport, index$l_workResult as workResult };
   export type { index$l_BlockView as BlockView, index$l_CodeHash as CodeHash, index$l_CoreIndex as CoreIndex, index$l_EntropyHash as EntropyHash, index$l_Epoch as Epoch, index$l_EpochMarkerView as EpochMarkerView, index$l_ExtrinsicHash as ExtrinsicHash, index$l_ExtrinsicView as ExtrinsicView, index$l_HeaderHash as HeaderHash, index$l_HeaderView as HeaderView, index$l_PerEpochBlock as PerEpochBlock, index$l_PerValidator as PerValidator, index$l_SEGMENT_BYTES as SEGMENT_BYTES, index$l_Segment as Segment, index$l_SegmentIndex as SegmentIndex, index$l_ServiceGas as ServiceGas, index$l_ServiceId as ServiceId, index$l_StateRootHash as StateRootHash, index$l_TicketsMarkerView as TicketsMarkerView, index$l_TimeSlot as TimeSlot, index$l_ValidatorIndex as ValidatorIndex, index$l_WorkReportHash as WorkReportHash };
 }
 
@@ -8373,7 +8414,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,49 +9152,62 @@ 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.
+ * `J`: The maximum sum of dependency items in a work-report.
  *
- * Used by "Assurances" and "Disputes" subsystem, denoted by `rho`
- * in state.
+ * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
+ */
+declare const MAX_REPORT_DEPENDENCIES = 8;
+type MAX_REPORT_DEPENDENCIES = typeof MAX_REPORT_DEPENDENCIES;
+
+/**
+ * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/135800135800
+ * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
  */
-declare class AvailabilityAssignment extends WithDebug {
-  static Codec = codec.Class(AvailabilityAssignment, {
-    workReport: codecWithHash(WorkReport.Codec),
-    timeout: codec.u32.asOpaque<TimeSlot>(),
+declare class NotYetAccumulatedReport extends WithDebug {
+  static Codec = codec.Class(NotYetAccumulatedReport, {
+    report: WorkReport.Codec,
+    dependencies: codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>(), {
+      typicalLength: MAX_REPORT_DEPENDENCIES / 2,
+      maxLength: MAX_REPORT_DEPENDENCIES,
+      minLength: 0,
+    }),
   });
 
-  static create({ workReport, timeout }: CodecRecord<AvailabilityAssignment>) {
-    return new AvailabilityAssignment(workReport, timeout);
+  static create({ report, dependencies }: CodecRecord<NotYetAccumulatedReport>) {
+    return new NotYetAccumulatedReport(report, dependencies);
   }
 
   private constructor(
-    /** Work report assigned to a core. */
-    public readonly workReport: WithHash<WorkReportHash, WorkReport>,
-    /** Time slot at which the report becomes obsolete. */
-    public readonly timeout: TimeSlot,
+    /**
+     * Each of these were made available at most one epoch ago
+     * but have or had unfulfilled dependencies.
+     */
+    readonly report: WorkReport,
+    /**
+     * Alongside the work-report itself, we retain its un-accumulated
+     * dependencies, a set of work-package hashes.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
+     */
+    readonly dependencies: KnownSizeArray<WorkPackageHash, `[0..${MAX_REPORT_DEPENDENCIES})`>,
   ) {
     super();
   }
 }
 
+/**
+ * Accumulation queue state entry.
+ */
+type AccumulationQueue = PerEpochBlock<readonly NotYetAccumulatedReport[]>;
+
+declare const accumulationQueueCodec = codecPerEpochBlock(
+  readonlyArray(codec.sequenceVarLen(NotYetAccumulatedReport.Codec)),
+);
+
+type AccumulationQueueView = DescribedBy<typeof accumulationQueueCodec.View>;
+
 /** One entry of kind `T` for each core. */
 type PerCore<T> = KnownSizeArray<T, "number of cores">;
 /** Check if given array has correct length before casting to the opaque type. */
@@ -9169,172 +9223,147 @@ declare const codecPerCore = <T, V>(val: Descriptor<T, V>): Descriptor<PerCore<T
     return codecKnownSizeArray(val, { fixedLength: context.coresCount });
   });
 
-declare const sortedSetCodec = <T extends OpaqueHash>() =>
-  readonlyArray(codec.sequenceVarLen(codec.bytes(HASH_SIZE))).convert<ImmutableSortedSet<T>>(
-    (input) => input.array,
-    (output) => {
-      const typed: T[] = output.map((x) => x.asOpaque());
-      return SortedSet.fromSortedArray(hashComparator, typed);
-    },
-  );
-declare const workReportsSortedSetCodec = sortedSetCodec<WorkReportHash>();
-
 /**
- * A set of judgements over particular work reports identified by hashes.
+ * Assignment of particular work report to a core.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/122b00124700
+ * Used by "Assurances" and "Disputes" subsystem, denoted by `rho`
+ * in state.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/135800135800
  */
-declare class DisputesRecords {
-  static Codec = codec.Class(DisputesRecords, {
-    goodSet: workReportsSortedSetCodec,
-    badSet: workReportsSortedSetCodec,
-    wonkySet: workReportsSortedSetCodec,
-    punishSet: sortedSetCodec(),
+declare class AvailabilityAssignment extends WithDebug {
+  static Codec = codec.Class(AvailabilityAssignment, {
+    workReport: WorkReport.Codec,
+    timeout: codec.u32.asOpaque<TimeSlot>(),
   });
 
-  static create({ goodSet, badSet, wonkySet, punishSet }: CodecRecord<DisputesRecords>) {
-    return new DisputesRecords(goodSet, badSet, wonkySet, punishSet);
+  static create({ workReport, timeout }: CodecRecord<AvailabilityAssignment>) {
+    return new AvailabilityAssignment(workReport, timeout);
   }
 
   private constructor(
-    /** `goodSet`: all work-reports hashes which were judged to be correct */
-    public readonly goodSet: ImmutableSortedSet<WorkReportHash>,
-    /** `badSet`: all work-reports hashes which were judged to be incorrect */
-    public readonly badSet: ImmutableSortedSet<WorkReportHash>,
-    /** `wonkySet`: all work-reports hashes which appear to be impossible to judge */
-    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>,
-  ) {}
-
-  static fromSortedArrays({
-    goodSet,
-    badSet,
-    wonkySet,
-    punishSet,
-  }: {
-    goodSet: WorkReportHash[];
-    badSet: WorkReportHash[];
-    wonkySet: WorkReportHash[];
-    punishSet: Ed25519Key[];
-  }) {
-    return new DisputesRecords(
-      SortedSet.fromSortedArray(hashComparator, goodSet),
-      SortedSet.fromSortedArray(hashComparator, badSet),
-      SortedSet.fromSortedArray(hashComparator, wonkySet),
-      SortedSet.fromSortedArray(hashComparator, punishSet),
-    );
+    /** Work report assigned to a core. */
+    public readonly workReport: WorkReport,
+    /** Time slot at which the report becomes obsolete. */
+    public readonly timeout: TimeSlot,
+  ) {
+    super();
   }
 }
 
-declare function hashComparator<V extends OpaqueHash>(a: V, b: V) {
-  return a.compare(b);
-}
+declare const availabilityAssignmentsCodec = codecPerCore(codec.optional(AvailabilityAssignment.Codec));
 
-// TODO [ToDr] Not sure where these should live yet :(
+type AvailabilityAssignmentsView = DescribedBy<typeof availabilityAssignmentsCodec.View>;
 
-/**
- * `J`: The maximum sum of dependency items in a work-report.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
- */
-declare const MAX_REPORT_DEPENDENCIES = 8;
-type MAX_REPORT_DEPENDENCIES = typeof MAX_REPORT_DEPENDENCIES;
+/** `O`: Maximal authorization pool size. */
+declare const MAX_AUTH_POOL_SIZE = O;
+type MAX_AUTH_POOL_SIZE = typeof MAX_AUTH_POOL_SIZE;
 
 /** `Q`: Size of the authorization queue. */
 declare const AUTHORIZATION_QUEUE_SIZE = Q;
 type AUTHORIZATION_QUEUE_SIZE = typeof AUTHORIZATION_QUEUE_SIZE;
 
-/** `O`: Maximal authorization pool size. */
-declare const MAX_AUTH_POOL_SIZE = O;
-type MAX_AUTH_POOL_SIZE = typeof MAX_AUTH_POOL_SIZE;
+/** A pool of authorization hashes that is filled from the queue. */
+type AuthorizationPool = KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>;
 
 /**
- * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
+ * A fixed-size queue of authorization hashes used to fill up the pool.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
+ * Can be set using `ASSIGN` host call in batches of `AUTHORIZATION_QUEUE_SIZE`.
  */
-declare class NotYetAccumulatedReport extends WithDebug {
-  static Codec = codec.Class(NotYetAccumulatedReport, {
-    report: WorkReport.Codec,
-    dependencies: codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>(), {
-      typicalLength: MAX_REPORT_DEPENDENCIES / 2,
-      maxLength: MAX_REPORT_DEPENDENCIES,
-      minLength: 0,
-    }),
-  });
+type AuthorizationQueue = FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>;
+
+declare const authPoolsCodec = codecPerCore<AuthorizationPool, SequenceView<AuthorizerHash>>(
+  codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), {
+    minLength: 0,
+    maxLength: MAX_AUTH_POOL_SIZE,
+    typicalLength: MAX_AUTH_POOL_SIZE,
+  }),
+);
 
-  static create({ report, dependencies }: CodecRecord<NotYetAccumulatedReport>) {
-    return new NotYetAccumulatedReport(report, dependencies);
-  }
+declare const authQueuesCodec = codecPerCore<AuthorizationQueue, SequenceView<AuthorizerHash>>(
+  codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), AUTHORIZATION_QUEUE_SIZE),
+);
 
-  private constructor(
-    /**
-     * Each of these were made available at most one epoch ago
-     * but have or had unfulfilled dependencies.
-     */
-    readonly report: WorkReport,
-    /**
-     * Alongside the work-report itself, we retain its un-accumulated
-     * dependencies, a set of work-package hashes.
-     *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
-     */
-    readonly dependencies: KnownSizeArray<WorkPackageHash, `[0..${MAX_REPORT_DEPENDENCIES})`>,
-  ) {
-    super();
-  }
-}
+declare const sortedSetCodec = <T extends OpaqueHash>() =>
+  readonlyArray(codec.sequenceVarLen(codec.bytes(HASH_SIZE))).convert<ImmutableSortedSet<T>>(
+    (input) => input.array,
+    (output) => {
+      const typed: T[] = output.map((x) => x.asOpaque());
+      return SortedSet.fromSortedArray(hashComparator, typed);
+    },
+  );
+declare const workReportsSortedSetCodec = sortedSetCodec<WorkReportHash>();
 
-/** 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>(),
+/**
+ * A set of judgements over particular work reports identified by hashes.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/122b00124700
+ */
+declare class DisputesRecords {
+  static Codec = codec.Class(DisputesRecords, {
+    goodSet: workReportsSortedSetCodec,
+    badSet: workReportsSortedSetCodec,
+    wonkySet: workReportsSortedSetCodec,
+    punishSet: sortedSetCodec(),
   });
 
-  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
-    return new AutoAccumulate(service, gasLimit);
+  static create({ goodSet, badSet, wonkySet, punishSet }: CodecRecord<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(
-    /** Service id that auto-accumulates. */
-    readonly service: ServiceId,
-    /** Gas limit for auto-accumulation. */
-    readonly gasLimit: ServiceGas,
-  ) {}
-}
+    /** `goodSet`: all work-reports hashes which were judged to be correct */
+    public readonly goodSet: ImmutableSortedSet<WorkReportHash>,
+    /** `badSet`: all work-reports hashes which were judged to be incorrect */
+    public readonly badSet: ImmutableSortedSet<WorkReportHash>,
+    /** `wonkySet`: all work-reports hashes which appear to be impossible to judge */
+    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);
+  }
 
-/**
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/11da0111da01?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)),
-  });
+  public asDictionaries() {
+    return {
+      goodSet: this.goodSetDict,
+      badSet: this.badSetDict,
+      wonkySet: this.wonkySetDict,
+      punishSet: this.punishSetDict,
+    };
+  }
 
-  static create({ manager, authManager, validatorsManager, autoAccumulateServices }: CodecRecord<PrivilegedServices>) {
-    return new PrivilegedServices(manager, authManager, validatorsManager, autoAccumulateServices);
+  static fromSortedArrays({
+    goodSet,
+    badSet,
+    wonkySet,
+    punishSet,
+  }: {
+    goodSet: WorkReportHash[];
+    badSet: WorkReportHash[];
+    wonkySet: WorkReportHash[];
+    punishSet: Ed25519Key[];
+  }) {
+    return new DisputesRecords(
+      SortedSet.fromSortedArray(hashComparator, goodSet),
+      SortedSet.fromSortedArray(hashComparator, badSet),
+      SortedSet.fromSortedArray(hashComparator, wonkySet),
+      SortedSet.fromSortedArray(hashComparator, punishSet),
+    );
   }
+}
 
-  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[],
-  ) {}
+declare function hashComparator<V extends OpaqueHash>(a: V, b: V) {
+  return a.compare(b);
 }
 
 declare const SUPER_PEAK_STRING = BytesBlob.blobFromString("peak");
@@ -9533,6 +9562,11 @@ declare class BlockState extends WithDebug {
   }
 }
 
+/**
+ * Recent history of blocks.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
+ */
 declare class RecentBlocks extends WithDebug {
   static Codec = codec.Class(RecentBlocks, {
     blocks: codecKnownSizeArray(BlockState.Codec, {
@@ -9545,6 +9579,12 @@ declare class RecentBlocks extends WithDebug {
     }),
   });
 
+  static empty() {
+    return new RecentBlocks(asKnownSize([]), {
+      peaks: [],
+    });
+  }
+
   static create(a: CodecRecord<RecentBlocks>) {
     return new RecentBlocks(a.blocks, a.accumulationLog);
   }
@@ -9565,78 +9605,21 @@ declare class RecentBlocks extends WithDebug {
   }
 }
 
-/**
- * Recent history of blocks.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
- */
-declare class RecentBlocksHistory extends WithDebug {
-  static Codec = Descriptor.new<RecentBlocksHistory>(
-    "RecentBlocksHistory",
-    RecentBlocks.Codec.sizeHint,
-    (encoder, value) => RecentBlocks.Codec.encode(encoder, value.asCurrent()),
-    (decoder) => {
-      const recentBlocks = RecentBlocks.Codec.decode(decoder);
-      return RecentBlocksHistory.create(recentBlocks);
-    },
-    (skip) => {
-      return RecentBlocks.Codec.skip(skip);
-    },
-  );
+type RecentBlocksView = DescribedBy<typeof RecentBlocks.Codec.View>;
 
-  static create(recentBlocks: RecentBlocks) {
-    return new RecentBlocksHistory(recentBlocks);
-  }
-
-  static empty() {
-    return RecentBlocksHistory.create(
-      RecentBlocks.create({
-        blocks: asKnownSize([]),
-        accumulationLog: { peaks: [] },
-      }),
-    );
-  }
-
-  /**
-   * Returns the block's BEEFY super peak.
-   */
-  static accumulationResult(block: BlockState): KeccakHash {
-    return (block as BlockState).accumulationResult;
-  }
-
-  private constructor(private readonly current: RecentBlocks | null) {
-    super();
-  }
+type RecentlyAccumulated = PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
 
-  /** History of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
-  get blocks(): readonly BlockState[] {
-    if (this.current !== null) {
-      return this.current.blocks;
-    }
-
-    throw new Error("RecentBlocksHistory is in invalid state");
-  }
-
-  asCurrent() {
-    if (this.current === null) {
-      throw new Error("Cannot access current RecentBlocks format");
-    }
-    return this.current;
-  }
-
-  updateBlocks(blocks: BlockState[]): RecentBlocksHistory {
-    if (this.current !== null) {
-      return RecentBlocksHistory.create(
-        RecentBlocks.create({
-          ...this.current,
-          blocks: asOpaqueType(blocks as BlockState[]),
-        }),
-      );
-    }
+declare const recentlyAccumulatedCodec = codecPerEpochBlock<
+  ImmutableHashSet<WorkPackageHash>,
+  SequenceView<WorkPackageHash>
+>(
+  codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>()).convert(
+    (x) => Array.from(x),
+    (x) => HashSet.from(x),
+  ),
+);
 
-    throw new Error("RecentBlocksHistory is in invalid state. Cannot be updated!");
-  }
-}
+type RecentlyAccumulatedView = DescribedBy<typeof recentlyAccumulatedCodec.View>;
 
 /**
  * Fixed size of validator metadata.
@@ -9677,6 +9660,10 @@ declare class ValidatorData extends WithDebug {
   }
 }
 
+type ValidatorDataView = DescribedBy<typeof ValidatorData.Codec.View>;
+
+declare const validatorsDataCodec = codecPerValidator(ValidatorData.Codec);
+
 declare enum SafroleSealingKeysKind {
   Tickets = 0,
   Keys = 1,
@@ -9781,6 +9768,8 @@ declare class SafroleData {
   ) {}
 }
 
+type SafroleDataView = DescribedBy<typeof SafroleData.Codec.View>;
+
 /**
  * `B_S`: The basic minimum balance which all services require.
  *
@@ -9815,6 +9804,31 @@ declare const ignoreValueWithDefault = <T>(defaultValue: T) =>
     (_s) => {},
   );
 
+/** Encode and decode object with leading version number. */
+declare const codecWithVersion = <T>(val: Descriptor<T>): Descriptor<T> =>
+  Descriptor.new<T>(
+    "withVersion",
+    {
+      bytes: val.sizeHint.bytes + 8,
+      isExact: false,
+    },
+    (e, v) => {
+      e.varU64(0n);
+      val.encode(e, v);
+    },
+    (d) => {
+      const version = d.varU64();
+      if (version !== 0n) {
+        throw new Error("Non-zero version is not supported!");
+      }
+      return val.decode(d);
+    },
+    (s) => {
+      s.varU64();
+      val.skip(s);
+    },
+  );
+
 /**
  * Service account details.
  *
@@ -9894,6 +9908,8 @@ declare class ServiceAccountInfo extends WithDebug {
   }
 }
 
+type ServiceAccountInfoView = DescribedBy<typeof ServiceAccountInfo.Codec.View>;
+
 declare class PreimageItem extends WithDebug {
   static Codec = codec.Class(PreimageItem, {
     hash: codec.bytes(HASH_SIZE).asOpaque<PreimageHash>(),
@@ -9965,6 +9981,66 @@ declare class LookupHistoryItem {
   }
 }
 
+/** 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 codecServiceId: Descriptor<ServiceId> =
   Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
     ? codec.u32.asOpaque<ServiceId>()
@@ -10105,12 +10181,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 +10213,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 +10269,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,
   ) {}
 
@@ -10227,6 +10319,8 @@ declare class StatisticsData {
   ) {}
 }
 
+type StatisticsDataView = DescribedBy<typeof StatisticsData.Codec.View>;
+
 /**
  * In addition to the entropy accumulator η_0, we retain
  * three additional historical values of the accumulator at
@@ -10278,7 +10372,7 @@ type State = {
   /**
    * `γₖ gamma_k`: The keys for the validators of the next epoch, equivalent to those keys which constitute γ_z .
    */
-  readonly nextValidatorData: SafroleData["nextValidatorData"];
+  readonly nextValidatorData: PerValidator<ValidatorData>;
 
   /**
    * `κ kappa`: Validators, who are the set of economic actors uniquely
@@ -10310,21 +10404,190 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/579bd12/186401186401
    */
-  readonly timeslot: TimeSlot;
+  readonly timeslot: TimeSlot;
+
+  /**
+   * `η eta`: An on-chain entropy pool is retained in η.
+   *
+   * https://graypaper.fluffylabs.dev/#/579bd12/080c01080d01
+   */
+  readonly entropy: FixedSizeArray<EntropyHash, ENTROPY_ENTRIES>;
+
+  /**
+   * `α alpha`: Authorizers available for each core (authorizer pool).
+   *
+   * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
+   */
+  readonly authPools: PerCore<AuthorizationPool>;
+
+  /**
+   * `φ phi`: A queue of authorizers for each core used to fill up the pool.
+   *
+   * Only updated by `accumulate` calls using `assign` host call.
+   *
+   * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
+   */
+  readonly authQueues: PerCore<AuthorizationQueue>;
+
+  /**
+   * `β beta`: State of the blocks from recent history.
+   *
+   * https://graypaper.fluffylabs.dev/#/579bd12/0fb7010fb701
+   */
+  readonly recentBlocks: RecentBlocks;
+
+  /**
+   * `π pi`: Previous and current statistics of each validator,
+   *         cores statistics and services statistics.
+   *
+   * https://graypaper.fluffylabs.dev/#/68eaa1f/18f60118f601?v=0.6.4
+   */
+  readonly statistics: StatisticsData;
+
+  /**
+   * `ϑ theta`: We also maintain knowledge of ready (i.e. available
+   * and/or audited) but not-yet-accumulated work-reports in
+   * the state item ϑ.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/165300165500
+   */
+  readonly accumulationQueue: AccumulationQueue;
+
+  /**
+   * `ξ xi`: In order to know which work-packages have been
+   * accumulated already, we maintain a history of what has
+   * been accumulated. This history, ξ, is sufficiently large
+   * for an epoch worth of work-reports.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/161a00161d00
+   */
+  readonly recentlyAccumulated: RecentlyAccumulated;
+
+  /*
+   * `γₐ gamma_a`: The ticket accumulator - a series of highest-scoring ticket identifiers to be
+   *               used for the next epoch.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/0dc3000dc500
+   */
+  readonly ticketsAccumulator: SafroleData["ticketsAccumulator"];
+
+  /**
+   * `γₛ gamma_s`: γs is the current epoch’s slot-sealer series, which is either a full complement
+   *                of `E` tickets or, in the case of a fallback mode, a series of `E` Bandersnatch
+   *                keys.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/0dc6000dc800
+   */
+  readonly sealingKeySeries: SafroleData["sealingKeySeries"];
+
+  /**
+   * `γ_z gamma_z`: The epoch’s root, a Bandersnatch ring root composed with the one Bandersnatch
+   *                key of each of the next epoch’s validators, defined in γ_k.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/0da8000db800
+   */
+  readonly epochRoot: SafroleData["epochRoot"];
+
+  /**
+   * `χ chi`: Up to three services may be recognized as privileged. The portion of state in which
+   *           this is held is denoted χ and has three service index components together with
+   *           a gas limit.
+   *
+   * https://graypaper.fluffylabs.dev/#/85129da/116f01117201?v=0.6.3
+   */
+  readonly privilegedServices: PrivilegedServices;
+
+  /**
+   * `θ theta`: Sequence of merkle mountain belts from recent accumulations
+   *            with service that accumulated them.
+   *
+   * https://graypaper.fluffylabs.dev/#/7e6ff6a/3bad023bad02?v=0.6.7
+   *
+   * NOTE Maximum size of this array is unspecified in GP
+   */
+  readonly accumulationOutputLog: SortedArray<AccumulationOutput>;
+
+  /**
+   * Retrieve details about single service.
+   */
+  getService(id: ServiceId): Service | null;
+};
+
+/** Service details. */
+interface Service {
+  /** Service id. */
+  readonly serviceId: ServiceId;
+
+  /** Retrieve service account info. */
+  getInfo(): ServiceAccountInfo;
+
+  /** Read one particular storage item. */
+  getStorage(storage: StorageKey): BytesBlob | null;
+
+  /** Check if preimage is present without retrieving the blob. */
+  hasPreimage(hash: PreimageHash): boolean;
+
+  /** Retrieve a preimage. */
+  getPreimage(hash: PreimageHash): BytesBlob | null;
+
+  /** Retrieve lookup history of a preimage. */
+  getLookupHistory(hash: PreimageHash, len: U32): LookupHistorySlots | null;
+}
+
+/** Additional marker interface, when state view is supported/required. */
+type WithStateView<V = StateView> = {
+  /** Get view of the state. */
+  view(): V;
+};
+
+/**
+ * A non-decoding version of the `State`.
+ *
+ * Note we don't require all fields to have view accessors, since
+ * it's only beneficial for large collections to be read via views.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/08f10008f100
+ */
+type StateView = {
+  /**
+
+   * `ρ rho`: work-reports which have been reported but are not yet known to be
+   *          available to a super-majority of validators, together with the time
+   *          at which each was reported.
+   *
+   *  https://graypaper.fluffylabs.dev/#/579bd12/135800135800
+   */
+  availabilityAssignmentView(): AvailabilityAssignmentsView;
+
+  /**
+   * `ι iota`: The validator keys and metadata to be drawn from next.
+   */
+  designatedValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
+
+  /**
+   * `κ kappa`: Validators, who are the set of economic actors uniquely
+   *            privileged to help build and maintain the Jam chain, are
+   *            identified within κ, archived in λ and enqueued from ι.
+   *
+   *  https://graypaper.fluffylabs.dev/#/579bd12/080201080601
+   */
+  currentValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
 
   /**
-   * `η eta`: An on-chain entropy pool is retained in η.
+   * `λ lambda`: Validators, who are the set of economic actors uniquely
+   *             privileged to help build and maintain the Jam chain, are
+   *             identified within κ, archived in λ and enqueued from ι.
    *
-   * https://graypaper.fluffylabs.dev/#/579bd12/080c01080d01
+   *  https://graypaper.fluffylabs.dev/#/579bd12/080201080601
    */
-  readonly entropy: FixedSizeArray<EntropyHash, ENTROPY_ENTRIES>;
+  previousValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
 
   /**
    * `α alpha`: Authorizers available for each core (authorizer pool).
    *
    * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
    */
-  readonly authPools: PerCore<KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>>;
+  authPoolsView(): SequenceView<AuthorizationPool, SequenceView<AuthorizerHash>>;
 
   /**
    * `φ phi`: A queue of authorizers for each core used to fill up the pool.
@@ -10333,14 +10596,14 @@ type State = {
    *
    * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
    */
-  readonly authQueues: PerCore<FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>>;
+  authQueuesView(): SequenceView<AuthorizationQueue, SequenceView<AuthorizerHash>>;
 
   /**
    * `β beta`: State of the blocks from recent history.
    *
    * https://graypaper.fluffylabs.dev/#/579bd12/0fb7010fb701
    */
-  readonly recentBlocks: RecentBlocksHistory;
+  recentBlocksView(): RecentBlocksView;
 
   /**
    * `π pi`: Previous and current statistics of each validator,
@@ -10348,7 +10611,7 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/68eaa1f/18f60118f601?v=0.6.4
    */
-  readonly statistics: StatisticsData;
+  statisticsView(): StatisticsDataView;
 
   /**
    * `ϑ theta`: We also maintain knowledge of ready (i.e. available
@@ -10357,7 +10620,7 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/5f542d7/165300165500
    */
-  readonly accumulationQueue: PerEpochBlock<readonly NotYetAccumulatedReport[]>;
+  accumulationQueueView(): AccumulationQueueView;
 
   /**
    * `ξ xi`: In order to know which work-packages have been
@@ -10367,79 +10630,17 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/5f542d7/161a00161d00
    */
-  readonly recentlyAccumulated: PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
+  recentlyAccumulatedView(): RecentlyAccumulatedView;
 
   /*
-   * `γₐ gamma_a`: The ticket accumulator - a series of highest-scoring ticket identifiers to be
-   *               used for the next epoch.
-   *
-   * https://graypaper.fluffylabs.dev/#/5f542d7/0dc3000dc500
-   */
-  readonly ticketsAccumulator: SafroleData["ticketsAccumulator"];
-
-  /**
-   * `γₛ gamma_s`: γs is the current epoch’s slot-sealer series, which is either a full complement
-   *                of `E` tickets or, in the case of a fallback mode, a series of `E` Bandersnatch
-   *                keys.
-   *
-   * https://graypaper.fluffylabs.dev/#/5f542d7/0dc6000dc800
-   */
-  readonly sealingKeySeries: SafroleData["sealingKeySeries"];
-
-  /**
-   * `γ_z gamma_z`: The epoch’s root, a Bandersnatch ring root composed with the one Bandersnatch
-   *                key of each of the next epoch’s validators, defined in γ_k.
-   *
-   * https://graypaper.fluffylabs.dev/#/5f542d7/0da8000db800
-   */
-  readonly epochRoot: SafroleData["epochRoot"];
-
-  /**
-   * `χ chi`: Up to three services may be recognized as privileged. The portion of state in which
-   *           this is held is denoted χ and has three service index components together with
-   *           a gas limit.
-   *
-   * https://graypaper.fluffylabs.dev/#/85129da/116f01117201?v=0.6.3
-   */
-  readonly privilegedServices: PrivilegedServices;
-
-  /**
-   * `θ theta`: Sequence of merkle mountain belts from recent accumulations
-   *            with service that accumulated them.
-   *
-   * https://graypaper.fluffylabs.dev/#/7e6ff6a/3bad023bad02?v=0.6.7
-   *
-   * NOTE Maximum size of this array is unspecified in GP
+   * `γ gamma`: Safrole data.
    */
-  readonly accumulationOutputLog: SortedArray<AccumulationOutput>;
+  safroleDataView(): SafroleDataView;
 
-  /**
-   * Retrieve details about single service.
-   */
-  getService(id: ServiceId): Service | null;
+  /** Retrieve details about single service. */
+  getServiceInfoView(id: ServiceId): ServiceAccountInfoView | null;
 };
 
-/** Service details. */
-interface Service {
-  /** Service id. */
-  readonly serviceId: ServiceId;
-
-  /** Retrieve service account info. */
-  getInfo(): ServiceAccountInfo;
-
-  /** Read one particular storage item. */
-  getStorage(storage: StorageKey): BytesBlob | null;
-
-  /** Check if preimage is present without retrieving the blob. */
-  hasPreimage(hash: PreimageHash): boolean;
-
-  /** Retrieve a preimage. */
-  getPreimage(hash: PreimageHash): BytesBlob | null;
-
-  /** Retrieve lookup history of a preimage. */
-  getLookupHistory(hash: PreimageHash, len: U32): LookupHistorySlots | null;
-}
-
 declare enum UpdatePreimageKind {
   /** Insert new preimage and optionally update it's lookup history. */
   Provide = 0,
@@ -10762,10 +10963,10 @@ declare class InMemoryService extends WithDebug implements Service {
 /**
  * A special version of state, stored fully in-memory.
  */
-declare class InMemoryState extends WithDebug implements State, EnumerableState {
+declare class InMemoryState extends WithDebug implements State, WithStateView, EnumerableState {
   /** Create a new `InMemoryState` by providing all required fields. */
-  static create(state: InMemoryStateFields) {
-    return new InMemoryState(state);
+  static new(chainSpec: ChainSpec, state: InMemoryStateFields) {
+    return new InMemoryState(chainSpec, state);
   }
 
   /**
@@ -10783,7 +10984,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
   /**
    * Create a new `InMemoryState` from some other state object.
    */
-  static copyFrom(other: State, servicesData: Map<ServiceId, ServiceEntries>) {
+  static copyFrom(chainSpec: ChainSpec, other: State, servicesData: Map<ServiceId, ServiceEntries>) {
     const services = new Map<ServiceId, InMemoryService>();
     for (const [id, entries] of servicesData.entries()) {
       const service = other.getService(id);
@@ -10794,7 +10995,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
       services.set(id, inMemService);
     }
 
-    return InMemoryState.create({
+    return InMemoryState.new(chainSpec, {
       availabilityAssignment: other.availabilityAssignment,
       accumulationQueue: other.accumulationQueue,
       designatedValidatorData: other.designatedValidatorData,
@@ -10989,12 +11190,12 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
   disputesRecords: DisputesRecords;
   timeslot: TimeSlot;
   entropy: FixedSizeArray<EntropyHash, ENTROPY_ENTRIES>;
-  authPools: PerCore<KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>>;
-  authQueues: PerCore<FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>>;
-  recentBlocks: RecentBlocksHistory;
+  authPools: PerCore<AuthorizationPool>;
+  authQueues: PerCore<AuthorizationQueue>;
+  recentBlocks: RecentBlocks;
   statistics: StatisticsData;
-  accumulationQueue: PerEpochBlock<readonly NotYetAccumulatedReport[]>;
-  recentlyAccumulated: PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
+  accumulationQueue: AccumulationQueue;
+  recentlyAccumulated: RecentlyAccumulated;
   ticketsAccumulator: KnownSizeArray<Ticket, "0...EpochLength">;
   sealingKeySeries: SafroleSealingKeys;
   epochRoot: BandersnatchRingRoot;
@@ -11010,7 +11211,10 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
     return this.services.get(id) ?? null;
   }
 
-  private constructor(s: InMemoryStateFields) {
+  protected constructor(
+    private readonly chainSpec: ChainSpec,
+    s: InMemoryStateFields,
+  ) {
     super();
     this.availabilityAssignment = s.availabilityAssignment;
     this.designatedValidatorData = s.designatedValidatorData;
@@ -11034,11 +11238,15 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
     this.services = s.services;
   }
 
+  view(): StateView {
+    return new InMemoryStateView(this.chainSpec, this);
+  }
+
   /**
    * Create an empty and possibly incoherent `InMemoryState`.
    */
   static empty(spec: ChainSpec) {
-    return new InMemoryState({
+    return new InMemoryState(spec, {
       availabilityAssignment: tryAsPerCore(
         Array.from({ length: spec.coresCount }, () => null),
         spec,
@@ -11105,7 +11313,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
         ),
         spec,
       ),
-      recentBlocks: RecentBlocksHistory.empty(),
+      recentBlocks: RecentBlocks.empty(),
       statistics: StatisticsData.create({
         current: tryAsPerValidator(
           Array.from({ length: spec.validatorsCount }, () => ValidatorStatistics.empty()),
@@ -11139,8 +11347,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, []),
@@ -11190,12 +11399,18 @@ type FieldNames<T> = {
   [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
+type index$e_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
 type index$e_AccumulationOutput = AccumulationOutput;
 declare const index$e_AccumulationOutput: typeof AccumulationOutput;
+type index$e_AccumulationQueue = AccumulationQueue;
+type index$e_AccumulationQueueView = AccumulationQueueView;
+type index$e_AuthorizationPool = AuthorizationPool;
+type index$e_AuthorizationQueue = AuthorizationQueue;
 type index$e_AutoAccumulate = AutoAccumulate;
 declare const index$e_AutoAccumulate: typeof AutoAccumulate;
 type index$e_AvailabilityAssignment = AvailabilityAssignment;
 declare const index$e_AvailabilityAssignment: typeof AvailabilityAssignment;
+type index$e_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
 declare const index$e_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
 type index$e_BlockState = BlockState;
 declare const index$e_BlockState: typeof BlockState;
@@ -11217,8 +11432,11 @@ type index$e_InMemoryStateFields = InMemoryStateFields;
 type index$e_LookupHistoryItem = LookupHistoryItem;
 declare const index$e_LookupHistoryItem: typeof LookupHistoryItem;
 type index$e_LookupHistorySlots = LookupHistorySlots;
+type index$e_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
 declare const index$e_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
 type index$e_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
+type index$e_NotYetAccumulatedReport = NotYetAccumulatedReport;
+declare const index$e_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
 type index$e_PerCore<T> = PerCore<T>;
 type index$e_PreimageItem = PreimageItem;
 declare const index$e_PreimageItem: typeof PreimageItem;
@@ -11226,10 +11444,12 @@ type index$e_PrivilegedServices = PrivilegedServices;
 declare const index$e_PrivilegedServices: typeof PrivilegedServices;
 type index$e_RecentBlocks = RecentBlocks;
 declare const index$e_RecentBlocks: typeof RecentBlocks;
-type index$e_RecentBlocksHistory = RecentBlocksHistory;
-declare const index$e_RecentBlocksHistory: typeof RecentBlocksHistory;
+type index$e_RecentBlocksView = RecentBlocksView;
+type index$e_RecentlyAccumulated = RecentlyAccumulated;
+type index$e_RecentlyAccumulatedView = RecentlyAccumulatedView;
 type index$e_SafroleData = SafroleData;
 declare const index$e_SafroleData: typeof SafroleData;
+type index$e_SafroleDataView = SafroleDataView;
 type index$e_SafroleSealingKeys = SafroleSealingKeys;
 type index$e_SafroleSealingKeysData = SafroleSealingKeysData;
 declare const index$e_SafroleSealingKeysData: typeof SafroleSealingKeysData;
@@ -11238,14 +11458,17 @@ declare const index$e_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
 type index$e_Service = Service;
 type index$e_ServiceAccountInfo = ServiceAccountInfo;
 declare const index$e_ServiceAccountInfo: typeof ServiceAccountInfo;
+type index$e_ServiceAccountInfoView = ServiceAccountInfoView;
 type index$e_ServiceData = ServiceData;
 type index$e_ServiceEntries = ServiceEntries;
 type index$e_ServiceStatistics = ServiceStatistics;
 declare const index$e_ServiceStatistics: typeof ServiceStatistics;
 type index$e_ServicesUpdate = ServicesUpdate;
 type index$e_State = State;
+type index$e_StateView = StateView;
 type index$e_StatisticsData = StatisticsData;
 declare const index$e_StatisticsData: typeof StatisticsData;
+type index$e_StatisticsDataView = StatisticsDataView;
 type index$e_StorageItem = StorageItem;
 declare const index$e_StorageItem: typeof StorageItem;
 type index$e_StorageKey = StorageKey;
@@ -11266,27 +11489,35 @@ declare const index$e_UpdateStorageKind: typeof UpdateStorageKind;
 type index$e_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
 type index$e_ValidatorData = ValidatorData;
 declare const index$e_ValidatorData: typeof ValidatorData;
+type index$e_ValidatorDataView = ValidatorDataView;
 type index$e_ValidatorStatistics = ValidatorStatistics;
 declare const index$e_ValidatorStatistics: typeof ValidatorStatistics;
+type index$e_WithStateView<V = StateView> = WithStateView<V>;
 declare const index$e_accumulationOutputComparator: typeof accumulationOutputComparator;
+declare const index$e_accumulationQueueCodec: typeof accumulationQueueCodec;
+declare const index$e_authPoolsCodec: typeof authPoolsCodec;
+declare const index$e_authQueuesCodec: typeof authQueuesCodec;
+declare const index$e_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
 declare const index$e_codecBandersnatchKey: typeof codecBandersnatchKey;
 declare const index$e_codecPerCore: typeof codecPerCore;
 declare const index$e_codecServiceId: typeof codecServiceId;
 declare const index$e_codecVarGas: typeof codecVarGas;
 declare const index$e_codecVarU16: typeof codecVarU16;
-declare const index$e_codecWithHash: typeof codecWithHash;
+declare const index$e_codecWithVersion: typeof codecWithVersion;
 declare const index$e_hashComparator: typeof hashComparator;
 declare const index$e_ignoreValueWithDefault: typeof ignoreValueWithDefault;
+declare const index$e_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
 declare const index$e_serviceDataCodec: typeof serviceDataCodec;
 declare const index$e_serviceEntriesCodec: typeof serviceEntriesCodec;
 declare const index$e_sortedSetCodec: typeof sortedSetCodec;
 declare const index$e_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
 declare const index$e_tryAsPerCore: typeof tryAsPerCore;
+declare const index$e_validatorsDataCodec: typeof validatorsDataCodec;
 declare const index$e_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
 declare const index$e_zeroSizeHint: typeof zeroSizeHint;
 declare namespace index$e {
-  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_RecentBlocksHistory as RecentBlocksHistory, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithHash as codecWithHash, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
-  export type { index$e_BlocksState as BlocksState, index$e_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$e_EnumerableState as EnumerableState, index$e_FieldNames as FieldNames, index$e_InMemoryStateFields as InMemoryStateFields, index$e_LookupHistorySlots as LookupHistorySlots, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
+  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_NotYetAccumulatedReport as NotYetAccumulatedReport, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, 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_accumulationQueueCodec as accumulationQueueCodec, index$e_authPoolsCodec as authPoolsCodec, index$e_authQueuesCodec as authQueuesCodec, index$e_availabilityAssignmentsCodec as availabilityAssignmentsCodec, 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_recentlyAccumulatedCodec as recentlyAccumulatedCodec, 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_validatorsDataCodec as validatorsDataCodec, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export type { index$e_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$e_AccumulationQueue as AccumulationQueue, index$e_AccumulationQueueView as AccumulationQueueView, index$e_AuthorizationPool as AuthorizationPool, index$e_AuthorizationQueue as AuthorizationQueue, index$e_AvailabilityAssignmentsView as AvailabilityAssignmentsView, 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_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_RecentBlocksView as RecentBlocksView, index$e_RecentlyAccumulated as RecentlyAccumulated, index$e_RecentlyAccumulatedView as RecentlyAccumulatedView, index$e_SafroleDataView as SafroleDataView, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceAccountInfoView as ServiceAccountInfoView, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StateView as StateView, index$e_StatisticsDataView as StatisticsDataView, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$e_ValidatorDataView as ValidatorDataView, index$e_WithStateView as WithStateView };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -11353,7 +11584,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 +11592,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 +11604,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 +11622,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);
@@ -11422,33 +11658,25 @@ declare function legacyServiceNested(serviceId: ServiceId, hash: OpaqueHash): St
   return key.asOpaque();
 }
 
-type StateCodec<T> = {
+type StateCodec<T, V = T> = {
   key: StateKey;
-  Codec: Descriptor<T>;
+  Codec: Descriptor<T, V>;
   extract: (s: State) => T;
 };
 
 /** Serialization for particular state entries. */
 declare namespace serialize {
   /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
-  export const authPools: StateCodec<State["authPools"]> = {
+  export const authPools: StateCodec<State["authPools"], ReturnType<StateView["authPoolsView"]>> = {
     key: stateKeys.index(StateKeyIdx.Alpha),
-    Codec: codecPerCore(
-      codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), {
-        minLength: 0,
-        maxLength: MAX_AUTH_POOL_SIZE,
-        typicalLength: MAX_AUTH_POOL_SIZE,
-      }),
-    ),
+    Codec: authPoolsCodec,
     extract: (s) => s.authPools,
   };
 
   /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
-  export const authQueues: StateCodec<State["authQueues"]> = {
+  export const authQueues: StateCodec<State["authQueues"], ReturnType<StateView["authQueuesView"]>> = {
     key: stateKeys.index(StateKeyIdx.Phi),
-    Codec: codecPerCore(
-      codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), AUTHORIZATION_QUEUE_SIZE),
-    ),
+    Codec: authQueuesCodec,
     extract: (s) => s.authQueues,
   };
 
@@ -11456,14 +11684,14 @@ declare namespace serialize {
    * C(3): Recent blocks with compatibility
    *  https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e013b3e01?v=0.6.7
    */
-  export const recentBlocks: StateCodec<State["recentBlocks"]> = {
+  export const recentBlocks: StateCodec<RecentBlocks, RecentBlocksView> = {
     key: stateKeys.index(StateKeyIdx.Beta),
-    Codec: RecentBlocksHistory.Codec,
+    Codec: RecentBlocks.Codec,
     extract: (s) => s.recentBlocks,
   };
 
   /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
-  export const safrole: StateCodec<SafroleData> = {
+  export const safrole: StateCodec<SafroleData, SafroleDataView> = {
     key: stateKeys.index(StateKeyIdx.Gamma),
     Codec: SafroleData.Codec,
     extract: (s) =>
@@ -11476,7 +11704,7 @@ declare namespace serialize {
   };
 
   /** C(5): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bba013bba01?v=0.6.7 */
-  export const disputesRecords: StateCodec<State["disputesRecords"]> = {
+  export const disputesRecords: StateCodec<DisputesRecords> = {
     key: stateKeys.index(StateKeyIdx.Psi),
     Codec: DisputesRecords.Codec,
     extract: (s) => s.disputesRecords,
@@ -11490,30 +11718,42 @@ declare namespace serialize {
   };
 
   /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
-  export const designatedValidators: StateCodec<State["designatedValidatorData"]> = {
+  export const designatedValidators: StateCodec<
+    State["designatedValidatorData"],
+    ReturnType<StateView["designatedValidatorDataView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Iota),
-    Codec: codecPerValidator(ValidatorData.Codec),
+    Codec: validatorsDataCodec,
     extract: (s) => s.designatedValidatorData,
   };
 
   /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
-  export const currentValidators: StateCodec<State["currentValidatorData"]> = {
+  export const currentValidators: StateCodec<
+    State["currentValidatorData"],
+    ReturnType<StateView["currentValidatorDataView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Kappa),
-    Codec: codecPerValidator(ValidatorData.Codec),
+    Codec: validatorsDataCodec,
     extract: (s) => s.currentValidatorData,
   };
 
   /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
-  export const previousValidators: StateCodec<State["previousValidatorData"]> = {
+  export const previousValidators: StateCodec<
+    State["previousValidatorData"],
+    ReturnType<StateView["previousValidatorDataView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Lambda),
-    Codec: codecPerValidator(ValidatorData.Codec),
+    Codec: validatorsDataCodec,
     extract: (s) => s.previousValidatorData,
   };
 
   /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
-  export const availabilityAssignment: StateCodec<State["availabilityAssignment"]> = {
+  export const availabilityAssignment: StateCodec<
+    State["availabilityAssignment"],
+    ReturnType<StateView["availabilityAssignmentView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Rho),
-    Codec: codecPerCore(codec.optional(AvailabilityAssignment.Codec)),
+    Codec: availabilityAssignmentsCodec,
     extract: (s) => s.availabilityAssignment,
   };
 
@@ -11532,28 +11772,29 @@ declare namespace serialize {
   };
 
   /** C(13): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b5e023b5e02?v=0.6.7 */
-  export const statistics: StateCodec<State["statistics"]> = {
+  export const statistics: StateCodec<StatisticsData, StatisticsDataView> = {
     key: stateKeys.index(StateKeyIdx.Pi),
     Codec: StatisticsData.Codec,
     extract: (s) => s.statistics,
   };
 
   /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
-  export const accumulationQueue: StateCodec<State["accumulationQueue"]> = {
+  export const accumulationQueue: StateCodec<
+    State["accumulationQueue"],
+    ReturnType<StateView["accumulationQueueView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Omega),
-    Codec: codecPerEpochBlock(readonlyArray(codec.sequenceVarLen(NotYetAccumulatedReport.Codec))),
+    Codec: accumulationQueueCodec,
     extract: (s) => s.accumulationQueue,
   };
 
   /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
-  export const recentlyAccumulated: StateCodec<State["recentlyAccumulated"]> = {
+  export const recentlyAccumulated: StateCodec<
+    State["recentlyAccumulated"],
+    ReturnType<StateView["recentlyAccumulatedView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Xi),
-    Codec: codecPerEpochBlock(
-      codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>()).convert(
-        (x) => Array.from(x),
-        (x) => HashSet.from(x),
-      ),
-    ),
+    Codec: recentlyAccumulatedCodec,
     extract: (s) => s.recentlyAccumulated,
   };
 
@@ -11570,24 +11811,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)),
   });
 }
@@ -11607,6 +11850,107 @@ declare const dumpCodec = Descriptor.new<BytesBlob>(
   (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()),
 );
 
+/**
+ * Abstraction over some backend containing serialized state entries.
+ *
+ * This may or may not be backed by some on-disk database or can be just stored in memory.
+ */
+interface SerializedStateBackend {
+  /** Retrieve given state key. */
+  get(key: StateKey): BytesBlob | null;
+}
+
+declare class SerializedStateView<T extends SerializedStateBackend> implements StateView {
+  constructor(
+    private readonly spec: ChainSpec,
+    public backend: T,
+    /** Best-effort list of recently active services. */
+    private readonly recentlyUsedServices: ServiceId[],
+    private readonly viewCache: HashDictionary<StateKey, unknown>,
+  ) {}
+
+  private retrieveView<A, B>({ key, Codec }: KeyAndCodecWithView<A, B>, description: string): B {
+    const cached = this.viewCache.get(key);
+    if (cached !== undefined) {
+      return cached as B;
+    }
+    const bytes = this.backend.get(key);
+    if (bytes === null) {
+      throw new Error(`Required state entry for ${description} is missing!. Accessing view of key: ${key}`);
+    }
+    // NOTE [ToDr] we are not using `Decoder.decodeObject` here because
+    // it needs to get to the end of the data (skip), yet that's expensive.
+    // we assume that the state data is correct and coherent anyway, so
+    // for performance reasons we simply create the view here.
+    const d = Decoder.fromBytesBlob(bytes);
+    d.attachContext(this.spec);
+    const view = Codec.View.decode(d);
+    this.viewCache.set(key, view);
+    return view;
+  }
+
+  availabilityAssignmentView(): AvailabilityAssignmentsView {
+    return this.retrieveView(serialize.availabilityAssignment, "availabilityAssignmentView");
+  }
+
+  designatedValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView> {
+    return this.retrieveView(serialize.designatedValidators, "designatedValidatorsView");
+  }
+
+  currentValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView> {
+    return this.retrieveView(serialize.currentValidators, "currentValidatorsView");
+  }
+
+  previousValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView> {
+    return this.retrieveView(serialize.previousValidators, "previousValidatorsView");
+  }
+
+  authPoolsView(): SequenceView<AuthorizationPool, SequenceView<AuthorizerHash>> {
+    return this.retrieveView(serialize.authPools, "authPoolsView");
+  }
+
+  authQueuesView(): SequenceView<AuthorizationQueue, SequenceView<AuthorizerHash>> {
+    return this.retrieveView(serialize.authQueues, "authQueuesView");
+  }
+
+  recentBlocksView(): RecentBlocksView {
+    return this.retrieveView(serialize.recentBlocks, "recentBlocksView");
+  }
+
+  statisticsView(): StatisticsDataView {
+    return this.retrieveView(serialize.statistics, "statisticsView");
+  }
+
+  accumulationQueueView(): AccumulationQueueView {
+    return this.retrieveView(serialize.accumulationQueue, "accumulationQueueView");
+  }
+
+  recentlyAccumulatedView(): RecentlyAccumulatedView {
+    return this.retrieveView(serialize.recentlyAccumulated, "recentlyAccumulatedView");
+  }
+
+  safroleDataView(): SafroleDataView {
+    return this.retrieveView(serialize.safrole, "safroleDataView");
+  }
+
+  getServiceInfoView(id: ServiceId): ServiceAccountInfoView | null {
+    const serviceData = serialize.serviceData(id);
+    const bytes = this.backend.get(serviceData.key);
+    if (bytes === null) {
+      return null;
+    }
+    if (!this.recentlyUsedServices.includes(id)) {
+      this.recentlyUsedServices.push(id);
+    }
+    return Decoder.decodeObject(serviceData.Codec.View, bytes, this.spec);
+  }
+}
+
+type KeyAndCodecWithView<T, V> = {
+  key: StateKey;
+  Codec: CodecWithView<T, V>;
+};
+
 /** What should be done with that key? */
 declare enum StateEntryUpdateAction {
   /** Insert an entry. */
@@ -11622,6 +11966,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 +11975,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 +11989,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 +12010,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 +12034,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 +12055,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 +12065,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 +12199,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 +12255,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 +12269,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 +12302,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()));
       }
     }
@@ -11972,16 +12329,6 @@ declare function convertInMemoryStateToDictionary(
   return serialized;
 }
 
-/**
- * Abstraction over some backend containing serialized state entries.
- *
- * This may or may not be backed by some on-disk database or can be just stored in memory.
- */
-interface SerializedStateBackend {
-  /** Retrieve given state key. */
-  get(key: StateKey): BytesBlob | null;
-}
-
 /**
  * State object which reads it's entries from some backend.
  *
@@ -11991,27 +12338,32 @@ interface SerializedStateBackend {
  * in the backend layer, so it MAY fail during runtime.
  */
 declare class SerializedState<T extends SerializedStateBackend = SerializedStateBackend>
-  implements State, EnumerableState
+  implements State, WithStateView, 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 dataCache: HashDictionary<StateKey, unknown> = HashDictionary.new();
+  private viewCache: HashDictionary<StateKey, unknown> = HashDictionary.new();
+
   private constructor(
     private readonly spec: ChainSpec,
+    private readonly blake2b: Blake2b,
     public backend: T,
     /** Best-effort list of recently active services. */
-    private readonly _recentServiceIds: ServiceId[],
+    private readonly recentlyUsedServices: ServiceId[],
   ) {}
 
   /** Comparing the serialized states, just means comparing their backends. */
@@ -12019,14 +12371,21 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
     return this.backend;
   }
 
+  /** Return a non-decoding version of the state. */
+  view(): StateView {
+    return new SerializedStateView(this.spec, this.backend, this.recentlyUsedServices, this.viewCache);
+  }
+
   // TODO [ToDr] Temporary method to update the state,
   // without changing references.
   public updateBackend(newBackend: T) {
     this.backend = newBackend;
+    this.dataCache = HashDictionary.new();
+    this.viewCache = HashDictionary.new();
   }
 
   recentServiceIds(): readonly ServiceId[] {
-    return this._recentServiceIds;
+    return this.recentlyUsedServices;
   }
 
   getService(id: ServiceId): SerializedService | null {
@@ -12035,27 +12394,33 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
       return null;
     }
 
-    if (!this._recentServiceIds.includes(id)) {
-      this._recentServiceIds.push(id);
+    if (!this.recentlyUsedServices.includes(id)) {
+      this.recentlyUsedServices.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 {
-    const bytes = this.backend.get(key);
-    if (bytes === null) {
-      throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${key}`);
+  private retrieve<T>(k: KeyAndCodec<T>, description: string): T {
+    const data = this.retrieveOptional(k);
+    if (data === undefined) {
+      throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${k.key}`);
     }
-    return Decoder.decodeObject(Codec, bytes, this.spec);
+    return data;
   }
 
   private retrieveOptional<T>({ key, Codec }: KeyAndCodec<T>): T | undefined {
+    const cached = this.dataCache.get(key);
+    if (cached !== undefined) {
+      return cached as T;
+    }
     const bytes = this.backend.get(key);
     if (bytes === null) {
       return undefined;
     }
-    return Decoder.decodeObject(Codec, bytes, this.spec);
+    const data = Decoder.decodeObject(Codec, bytes, this.spec);
+    this.dataCache.set(key, data);
+    return data;
   }
 
   get availabilityAssignment(): State["availabilityAssignment"] {
@@ -12138,6 +12503,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 +12519,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 +12536,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 +12559,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);
 }
 
 /**
@@ -12227,12 +12593,15 @@ declare function loadState(spec: ChainSpec, entries: Iterable<[StateKey | Trunca
 declare const index$d_EMPTY_BLOB: typeof EMPTY_BLOB;
 type index$d_EncodeFun = EncodeFun;
 type index$d_KeyAndCodec<T> = KeyAndCodec<T>;
+type index$d_KeyAndCodecWithView<T, V> = KeyAndCodecWithView<T, V>;
 type index$d_SerializedService = SerializedService;
 declare const index$d_SerializedService: typeof SerializedService;
 type index$d_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
 declare const index$d_SerializedState: typeof SerializedState;
 type index$d_SerializedStateBackend = SerializedStateBackend;
-type index$d_StateCodec<T> = StateCodec<T>;
+type index$d_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
+declare const index$d_SerializedStateView: typeof SerializedStateView;
+type index$d_StateCodec<T, V = T> = StateCodec<T, V>;
 type index$d_StateEntries = StateEntries;
 declare const index$d_StateEntries: typeof StateEntries;
 type index$d_StateEntryUpdate = StateEntryUpdate;
@@ -12260,8 +12629,8 @@ declare const index$d_serializeStorage: typeof serializeStorage;
 declare const index$d_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
 import index$d_stateKeys = stateKeys;
 declare namespace index$d {
-  export { index$d_EMPTY_BLOB as EMPTY_BLOB, index$d_SerializedService as SerializedService, index$d_SerializedState as SerializedState, index$d_StateEntries as StateEntries, index$d_StateEntryUpdateAction as StateEntryUpdateAction, index$d_StateKeyIdx as StateKeyIdx, index$d_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$d_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$d_U32_BYTES as U32_BYTES, index$d_binaryMerkleization as binaryMerkleization, index$d_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$d_dumpCodec as dumpCodec, index$d_getSafroleData as getSafroleData, index$d_legacyServiceNested as legacyServiceNested, index$d_loadState as loadState, index$d_serialize as serialize, index$d_serializeBasicKeys as serializeBasicKeys, index$d_serializePreimages as serializePreimages, index$d_serializeRemovedServices as serializeRemovedServices, index$d_serializeServiceUpdates as serializeServiceUpdates, index$d_serializeStateUpdate as serializeStateUpdate, index$d_serializeStorage as serializeStorage, index$d_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$d_stateKeys as stateKeys };
-  export type { index$d_EncodeFun as EncodeFun, index$d_KeyAndCodec as KeyAndCodec, index$d_SerializedStateBackend as SerializedStateBackend, index$d_StateCodec as StateCodec, index$d_StateEntryUpdate as StateEntryUpdate, index$d_StateKey as StateKey };
+  export { index$d_EMPTY_BLOB as EMPTY_BLOB, index$d_SerializedService as SerializedService, index$d_SerializedState as SerializedState, index$d_SerializedStateView as SerializedStateView, index$d_StateEntries as StateEntries, index$d_StateEntryUpdateAction as StateEntryUpdateAction, index$d_StateKeyIdx as StateKeyIdx, index$d_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$d_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$d_U32_BYTES as U32_BYTES, index$d_binaryMerkleization as binaryMerkleization, index$d_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$d_dumpCodec as dumpCodec, index$d_getSafroleData as getSafroleData, index$d_legacyServiceNested as legacyServiceNested, index$d_loadState as loadState, index$d_serialize as serialize, index$d_serializeBasicKeys as serializeBasicKeys, index$d_serializePreimages as serializePreimages, index$d_serializeRemovedServices as serializeRemovedServices, index$d_serializeServiceUpdates as serializeServiceUpdates, index$d_serializeStateUpdate as serializeStateUpdate, index$d_serializeStorage as serializeStorage, index$d_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$d_stateKeys as stateKeys };
+  export type { index$d_EncodeFun as EncodeFun, index$d_KeyAndCodec as KeyAndCodec, index$d_KeyAndCodecWithView as KeyAndCodecWithView, index$d_SerializedStateBackend as SerializedStateBackend, index$d_StateCodec as StateCodec, index$d_StateEntryUpdate as StateEntryUpdate, index$d_StateKey as StateKey };
 }
 
 /** Error during `LeafDb` creation. */
@@ -12351,7 +12720,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,12 +12819,13 @@ 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. */
   async insertState(headerHash: HeaderHash, state: InMemoryState): Promise<Result$2<OK, StateUpdateError>> {
-    const encoded = Encoder.encodeObject(inMemoryStateCodec, state, this.spec);
+    const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
     this.db.set(headerHash, encoded);
     return Result.ok(OK);
   }
@@ -12465,7 +12836,7 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
       return null;
     }
 
-    return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
+    return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
   }
 }
 
@@ -12554,7 +12925,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 +12981,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 +13001,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 +13021,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 +13148,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 +13991,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 +14048,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 of that service.
-   * https://graypaper.fluffylabs.dev/#/7e6ff6a/2f4c022f4c02?v=0.6.7
+   * Returns a newly assigned id
+   * or `wantedServiceId` if it's lower than `S`
+   * and parent of that service is `Registrar`.
+   *
+   * https://graypaper.fluffylabs.dev/#/ab2cdbd/2fa9042fc304?v=0.7.2
    *
    * An error can be returned in case the account does not
    * have the required balance
-   * or tries to set gratis storage without being privileged.
+   * or tries to set gratis storage without being `Manager`
+   * or `Registrar` tries to set service id thats already taken.
    */
   newService(
     codeHash: CodeHash,
@@ -13701,6 +14077,7 @@ interface PartialState {
     gas: ServiceGas,
     allowance: ServiceGas,
     gratisStorage: U64,
+    wantedServiceId: U64,
   ): Result$2<ServiceId, NewServiceError>;
 
   /** Upgrade code of currently running service. */
@@ -13721,8 +14098,8 @@ interface PartialState {
   /** Update authorization queue for given core and authorize a service for this core. */
   updateAuthorizationQueue(
     coreIndex: CoreIndex,
-    authQueue: FixedSizeArray<Blake2bHash, AUTHORIZATION_QUEUE_SIZE>,
-    authManager: ServiceId | null,
+    authQueue: AuthorizationQueue,
+    assigner: ServiceId | null,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /**
@@ -13731,14 +14108,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 +14229,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 +14373,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);
@@ -17446,6 +17825,29 @@ declare class Interpreter {
   getMemoryPage(pageNumber: number): null | Uint8Array {
     return this.memory.getPageDump(tryAsPageNumber(pageNumber));
   }
+
+  calculateBlockGasCost(): Map<string, number> {
+    const codeLength = this.code.length;
+    const blocks: Map<string, number> = new Map();
+    let currentBlock = "0";
+    let gasCost = 0;
+    const getNextIstructionIndex = (index: number) => index + 1 + this.mask.getNoOfBytesToNextInstruction(index + 1);
+
+    for (let index = 0; index < codeLength; index = getNextIstructionIndex(index)) {
+      const instruction = this.code[index];
+      if (this.basicBlocks.isBeginningOfBasicBlock(index)) {
+        blocks.set(currentBlock, gasCost);
+        currentBlock = index.toString();
+        gasCost = 0;
+      }
+
+      gasCost += instructionGasMap[instruction];
+    }
+
+    blocks.set(currentBlock, gasCost);
+
+    return blocks;
+  }
 }
 
 type index$8_BigGas = BigGas;
@@ -17656,7 +18058,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 +18109,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 +18387,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 +18395,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 +18461,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 +18482,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 +18630,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 +18663,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 +18693,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 +19069,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 +19078,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 +19271,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 +19300,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 +19339,7 @@ declare class JsonServiceInfo {
     },
   );
 
+  version?: number;
   code_hash!: CodeHash;
   balance!: U64;
   min_item_gas!: ServiceGas;
@@ -18958,6 +19386,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 +19411,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 +19465,8 @@ declare class JsonService {
     preimages?: JsonPreimageItem[];
     storage?: JsonStorageItem[];
     lookup_meta?: LookupHistoryItem[];
+    preimages_blob?: JsonPreimageItem[];
+    preimages_status?: LookupHistoryItem[];
   };
 }
 
@@ -19020,8 +19476,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 });
   },
 );
 
@@ -19109,7 +19564,7 @@ type JsonRecentBlockState = {
   reported: WorkPackageInfo[];
 };
 
-declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, RecentBlocksHistory>(
+declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, RecentBlocks>(
   {
     history: json.array(recentBlockStateFromJson),
     mmr: {
@@ -19117,12 +19572,10 @@ declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, Recent
     },
   },
   ({ history, mmr }) => {
-    return RecentBlocksHistory.create(
-      RecentBlocks.create({
-        blocks: history,
-        accumulationLog: mmr,
-      }),
-    );
+    return RecentBlocks.create({
+      blocks: history,
+      accumulationLog: mmr,
+    });
   },
 );
 
@@ -19242,8 +19695,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 +19727,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 +19743,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 +19816,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 +19851,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,7 +19884,10 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
       theta,
       accounts,
     }): InMemoryState => {
-      return InMemoryState.create({
+      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.new(spec, {
         authPools: tryAsPerCore(
           alpha.map((perCore) => {
             if (perCore.length > MAX_AUTH_POOL_SIZE) {
@@ -19444,7 +19906,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
           }),
           spec,
         ),
-        recentBlocks: beta ?? RecentBlocksHistory.empty(),
+        recentBlocks: beta ?? RecentBlocks.empty(),
         nextValidatorData: gamma.gamma_k,
         epochRoot: gamma.gamma_z,
         sealingKeySeries: TicketsOrKeys.toSafroleSealingKeys(gamma.gamma_s, spec),
@@ -19458,8 +19920,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 +19945,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 +19970,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 +19978,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 +19987,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 +20001,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);
   }
 
   /**
@@ -19546,29 +20011,31 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
    */
   extrinsic(extrinsicView: ExtrinsicView): WithHashAndBytes<ExtrinsicHash, ExtrinsicView> {
     // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
-    const guarantees = extrinsicView.guarantees
+    const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
+    const countEncoded = Encoder.encodeObject(codec.varU32, guaranteesCount);
+    const guaranteesBlobs = extrinsicView.guarantees
       .view()
       .map((g) => g.view())
-      .map((guarantee) => {
-        const reportHash = blake2b.hashBytes(guarantee.report.encoded(), this.allocator).asOpaque<WorkReportHash>();
-        return BytesBlob.blobFromParts([
-          reportHash.raw,
-          guarantee.slot.encoded().raw,
-          guarantee.credentials.encoded().raw,
-        ]);
-      });
-
-    const guaranteeBlob = Encoder.encodeObject(codec.sequenceVarLen(dumpCodec), guarantees, this.context);
+      .reduce(
+        (aggregated, guarantee) => {
+          const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque<WorkReportHash>();
+          aggregated.push(reportHash.raw);
+          aggregated.push(guarantee.slot.encoded().raw);
+          aggregated.push(guarantee.credentials.encoded().raw);
+          return aggregated;
+        },
+        [countEncoded.raw],
+      );
 
-    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.hashBlobs(guaranteesBlobs).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 +20046,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 +20067,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 +20099,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 +20130,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 +20139,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 };
 }