@typeberry/lib 0.1.3-af70ed0 → 0.1.3-c2321fb

package/index.d.ts

@@ -420,6 +420,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.
  */
@@ -755,11 +769,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 +944,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 +1027,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 +1148,7 @@ declare class BitVec {
    * Create new [`BitVec`] with all values set to `false`.
    */
   static empty(bitLength: number) {
-    const data = new Uint8Array(Math.ceil(bitLength / 8));
+    const data = safeAllocUint8Array(Math.ceil(bitLength / 8));
     return new BitVec(data, bitLength);
   }
 
@@ -3461,6 +3476,52 @@ declare namespace index$q {
   export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
 }
 
+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 +3577,46 @@ declare class WithHashAndBytes<THash extends OpaqueHash, TData> extends WithHash
   }
 }
 
-/** Allocator interface - returns an empty bytes vector that can be filled with the hash. */
-interface HashAllocator {
-  /** Return a new hash destination. */
-  emptyHash(): OpaqueHash;
-}
-
-/** The simplest allocator returning just a fresh copy of bytes each time. */
-declare class SimpleAllocator implements HashAllocator {
-  emptyHash(): OpaqueHash {
-    return Bytes.zero(HASH_SIZE);
-  }
-}
-
-/** An allocator that works by allocating larger (continuous) pages of memory. */
-declare class PageAllocator implements HashAllocator {
-  private page: Uint8Array = new Uint8Array(0);
-  private currentHash = 0;
-
-  // TODO [ToDr] Benchmark the performance!
-  constructor(private readonly hashesPerPage: number) {
-    check`${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
-    this.resetPage();
-  }
+declare const zero$1 = Bytes.zero(HASH_SIZE);
 
-  private resetPage() {
-    const pageSizeBytes = this.hashesPerPage * HASH_SIZE;
-    this.currentHash = 0;
-    this.page = new Uint8Array(pageSizeBytes);
+declare class Blake2b {
+  static async createHasher() {
+    return new Blake2b(await createBLAKE2b(HASH_SIZE * 8));
   }
 
-  emptyHash(): OpaqueHash {
-    const startIdx = this.currentHash * HASH_SIZE;
-    const endIdx = startIdx + HASH_SIZE;
+  private constructor(private readonly hasher: IHasher) {}
 
-    this.currentHash += 1;
-    if (this.currentHash >= this.hashesPerPage) {
-      this.resetPage();
+  /**
+   * Hash given collection of blobs.
+   *
+   * If empty array is given a zero-hash is returned.
+   */
+  hashBlobs<H extends Blake2bHash>(r: (BytesBlob | Uint8Array)[]): H {
+    if (r.length === 0) {
+      return zero.asOpaque();
     }
 
-    return Bytes.fromBlob(this.page.subarray(startIdx, endIdx), HASH_SIZE);
+    const hasher = this.hasher.init();
+    for (const v of r) {
+      hasher.update(v instanceof BytesBlob ? v.raw : v);
+    }
+    return Bytes.fromBlob(hasher.digest("binary"), HASH_SIZE).asOpaque();
   }
-}
-
-declare const defaultAllocator = new SimpleAllocator();
 
-/**
- * Hash given collection of blobs.
- *
- * If empty array is given a zero-hash is returned.
- */
-declare function hashBlobs$1<H extends Blake2bHash>(
-  r: (BytesBlob | Uint8Array)[],
-  allocator: HashAllocator = defaultAllocator,
-): H {
-  const out = allocator.emptyHash();
-  if (r.length === 0) {
-    return out.asOpaque();
+  /** Hash given blob of bytes. */
+  hashBytes(blob: BytesBlob | Uint8Array): Blake2bHash {
+    const hasher = this.hasher.init();
+    const bytes = blob instanceof BytesBlob ? blob.raw : blob;
+    hasher.update(bytes);
+    return Bytes.fromBlob(hasher.digest("binary"), HASH_SIZE).asOpaque();
   }
 
-  const hasher = blake2b(HASH_SIZE);
-  for (const v of r) {
-    hasher?.update(v instanceof BytesBlob ? v.raw : v);
+  /** Convert given string into bytes and hash it. */
+  hashString(str: string) {
+    return this.hashBytes(BytesBlob.blobFromString(str));
   }
-  hasher?.digest(out.raw);
-  return out.asOpaque();
 }
 
-/** Hash given blob of bytes. */
-declare function hashBytes(blob: BytesBlob | Uint8Array, allocator: HashAllocator = defaultAllocator): Blake2bHash {
-  const hasher = blake2b(HASH_SIZE);
-  const bytes = blob instanceof BytesBlob ? blob.raw : blob;
-  hasher?.update(bytes);
-  const out = allocator.emptyHash();
-  hasher?.digest(out.raw);
-  return out;
-}
-
-/** Convert given string into bytes and hash it. */
-declare function hashString(str: string, allocator: HashAllocator = defaultAllocator) {
-  return hashBytes(BytesBlob.blobFromString(str), allocator);
-}
-
-declare const blake2b_hashBytes: typeof hashBytes;
-declare const blake2b_hashString: typeof hashString;
-declare namespace blake2b {
-  export {
-    hashBlobs$1 as hashBlobs,
-    blake2b_hashBytes as hashBytes,
-    blake2b_hashString as hashString,
-  };
-}
-
-type ITypedArray = Uint8Array | Uint16Array | Uint32Array;
-type IDataType = string | Buffer | ITypedArray;
-
-type IHasher = {
-    /**
-     * Initializes hash state to default value
-     */
-    init: () => IHasher;
-    /**
-     * Updates the hash content with the given data
-     */
-    update: (data: IDataType) => IHasher;
-    /**
-     * Calculates the hash of all of the data passed to be hashed with hash.update().
-     * Defaults to hexadecimal string
-     * @param outputType If outputType is "binary", it returns Uint8Array. Otherwise it
-     *                   returns hexadecimal string
-     */
-    digest: {
-        (outputType: "binary"): Uint8Array;
-        (outputType?: "hex"): string;
-    };
-    /**
-     * Save the current internal state of the hasher for later resumption with load().
-     * Cannot be called before .init() or after .digest()
-     *
-     * Note that this state can include arbitrary information about the value being hashed (e.g.
-     * could include N plaintext bytes from the value), so needs to be treated as being as
-     * sensitive as the input value itself.
-     */
-    save: () => Uint8Array;
-    /**
-     * Resume a state that was created by save(). If this state was not created by a
-     * compatible build of hash-wasm, an exception will be thrown.
-     */
-    load: (state: Uint8Array) => IHasher;
-    /**
-     * Block size in bytes
-     */
-    blockSize: number;
-    /**
-     * Digest size in bytes
-     */
-    digestSize: number;
-};
-
 declare class KeccakHasher {
   static async create(): Promise<KeccakHasher> {
     return new KeccakHasher(await createKeccak(256));
@@ -3681,15 +3644,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 +3660,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`. */
@@ -4735,7 +4696,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 +4786,16 @@ declare function trivialSeed(s: U32): KeySeed {
  * Derives a Ed25519 secret key from a seed.
  * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
  */
-declare function deriveEd25519SecretKey(
-  seed: KeySeed,
-  allocator: SimpleAllocator = new SimpleAllocator(),
-): Ed25519SecretSeed {
-  return blake2b.hashBytes(BytesBlob.blobFromParts([ED25519_SECRET_KEY.raw, seed.raw]), allocator).asOpaque();
+declare function deriveEd25519SecretKey(seed: KeySeed, blake2b: Blake2b): Ed25519SecretSeed {
+  return blake2b.hashBytes(BytesBlob.blobFromParts([ED25519_SECRET_KEY.raw, seed.raw])).asOpaque();
 }
 
 /**
  * Derives a Bandersnatch secret key from a seed.
  * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
  */
-declare function deriveBandersnatchSecretKey(
-  seed: KeySeed,
-  allocator: SimpleAllocator = new SimpleAllocator(),
-): BandersnatchSecretSeed {
-  return blake2b.hashBytes(BytesBlob.blobFromParts([BANDERSNATCH_SECRET_KEY.raw, seed.raw]), allocator).asOpaque();
+declare function deriveBandersnatchSecretKey(seed: KeySeed, blake2b: Blake2b): BandersnatchSecretSeed {
+  return blake2b.hashBytes(BytesBlob.blobFromParts([BANDERSNATCH_SECRET_KEY.raw, seed.raw])).asOpaque();
 }
 
 /**
@@ -8373,7 +8328,7 @@ declare enum NodeType {
 declare class TrieNode {
   constructor(
     /** Exactly 512 bits / 64 bytes */
-    public readonly raw: Uint8Array = new Uint8Array(TRIE_NODE_BYTES),
+    public readonly raw: Uint8Array = safeAllocUint8Array(TRIE_NODE_BYTES),
   ) {}
 
   /** Returns the type of the node */
@@ -9111,21 +9066,6 @@ declare function accumulationOutputComparator(a: AccumulationOutput, b: Accumula
   return Ordering.Equal;
 }
 
-declare const codecWithHash = <T, V, H extends OpaqueHash>(val: Descriptor<T, V>): Descriptor<WithHash<H, T>, V> =>
-  Descriptor.withView(
-    val.name,
-    val.sizeHint,
-    (e, elem) => val.encode(e, elem.data),
-    (d): WithHash<H, T> => {
-      const decoder2 = d.clone();
-      const encoded = val.skipEncoded(decoder2);
-      const hash = blake2b.hashBytes(encoded);
-      return new WithHash(hash.asOpaque(), val.decode(d));
-    },
-    val.skip,
-    val.View,
-  );
-
 /**
  * Assignment of particular work report to a core.
  *
@@ -9136,7 +9076,7 @@ declare const codecWithHash = <T, V, H extends OpaqueHash>(val: Descriptor<T, V>
  */
 declare class AvailabilityAssignment extends WithDebug {
   static Codec = codec.Class(AvailabilityAssignment, {
-    workReport: codecWithHash(WorkReport.Codec),
+    workReport: WorkReport.Codec,
     timeout: codec.u32.asOpaque<TimeSlot>(),
   });
 
@@ -9146,7 +9086,7 @@ declare class AvailabilityAssignment extends WithDebug {
 
   private constructor(
     /** Work report assigned to a core. */
-    public readonly workReport: WithHash<WorkReportHash, WorkReport>,
+    public readonly workReport: WorkReport,
     /** Time slot at which the report becomes obsolete. */
     public readonly timeout: TimeSlot,
   ) {
@@ -11293,7 +11233,6 @@ 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_hashComparator: typeof hashComparator;
 declare const index$e_ignoreValueWithDefault: typeof ignoreValueWithDefault;
 declare const index$e_serviceDataCodec: typeof serviceDataCodec;
@@ -11304,7 +11243,7 @@ declare const index$e_tryAsPerCore: typeof tryAsPerCore;
 declare const index$e_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
 declare const index$e_zeroSizeHint: typeof zeroSizeHint;
 declare namespace index$e {
-  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_RecentBlocksHistory as RecentBlocksHistory, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithHash as codecWithHash, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_RecentBlocksHistory as RecentBlocksHistory, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
   export type { index$e_BlocksState as BlocksState, index$e_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$e_EnumerableState as EnumerableState, index$e_FieldNames as FieldNames, index$e_InMemoryStateFields as InMemoryStateFields, index$e_LookupHistorySlots as LookupHistorySlots, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
 }
 
@@ -11372,7 +11311,7 @@ declare namespace stateKeys {
   }
 
   /** https://graypaper.fluffylabs.dev/#/1c979cb/3bba033bba03?v=0.7.1 */
-  export function serviceStorage(serviceId: ServiceId, key: StorageKey): StateKey {
+  export function serviceStorage(blake2b: Blake2b, serviceId: ServiceId, key: StorageKey): StateKey {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const out = Bytes.zero(HASH_SIZE);
       out.raw.set(u32AsLeBytes(tryAsU32(2 ** 32 - 1)), 0);
@@ -11380,11 +11319,11 @@ declare namespace stateKeys {
       return legacyServiceNested(serviceId, out);
     }
 
-    return serviceNested(serviceId, tryAsU32(2 ** 32 - 1), key);
+    return serviceNested(blake2b, serviceId, tryAsU32(2 ** 32 - 1), key);
   }
 
   /** https://graypaper.fluffylabs.dev/#/1c979cb/3bd7033bd703?v=0.7.1 */
-  export function servicePreimage(serviceId: ServiceId, hash: PreimageHash): StateKey {
+  export function servicePreimage(blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash): StateKey {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const out = Bytes.zero(HASH_SIZE);
       out.raw.set(u32AsLeBytes(tryAsU32(2 ** 32 - 2)), 0);
@@ -11392,11 +11331,16 @@ declare namespace stateKeys {
       return legacyServiceNested(serviceId, out);
     }
 
-    return serviceNested(serviceId, tryAsU32(2 ** 32 - 2), hash);
+    return serviceNested(blake2b, serviceId, tryAsU32(2 ** 32 - 2), hash);
   }
 
   /** https://graypaper.fluffylabs.dev/#/1c979cb/3b0a043b0a04?v=0.7.1 */
-  export function serviceLookupHistory(serviceId: ServiceId, hash: PreimageHash, preimageLength: U32): StateKey {
+  export function serviceLookupHistory(
+    blake2b: Blake2b,
+    serviceId: ServiceId,
+    hash: PreimageHash,
+    preimageLength: U32,
+  ): StateKey {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const doubleHash = blake2b.hashBytes(hash);
       const out = Bytes.zero(HASH_SIZE);
@@ -11405,11 +11349,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);
@@ -11593,20 +11537,20 @@ declare namespace serialize {
   });
 
   /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
-  export const serviceStorage = (serviceId: ServiceId, key: StorageKey) => ({
-    key: stateKeys.serviceStorage(serviceId, key),
+  export const serviceStorage = (blake2b: Blake2b, serviceId: ServiceId, key: StorageKey) => ({
+    key: stateKeys.serviceStorage(blake2b, serviceId, key),
     Codec: dumpCodec,
   });
 
   /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
-  export const servicePreimages = (serviceId: ServiceId, hash: PreimageHash) => ({
-    key: stateKeys.servicePreimage(serviceId, hash),
+  export const servicePreimages = (blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash) => ({
+    key: stateKeys.servicePreimage(blake2b, serviceId, hash),
     Codec: dumpCodec,
   });
 
   /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
-  export const serviceLookupHistory = (serviceId: ServiceId, hash: PreimageHash, len: U32) => ({
-    key: stateKeys.serviceLookupHistory(serviceId, hash, len),
+  export const serviceLookupHistory = (blake2b: Blake2b, serviceId: ServiceId, hash: PreimageHash, len: U32) => ({
+    key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
     Codec: readonlyArray(codec.sequenceVarLen(codec.u32)),
   });
 }
@@ -11641,6 +11585,7 @@ declare const EMPTY_BLOB = BytesBlob.empty();
 /** Serialize given state update into a series of key-value pairs. */
 declare function* serializeStateUpdate(
   spec: ChainSpec,
+  blake2b: Blake2b,
   update: Partial<State & ServicesUpdate>,
 ): Generator<StateEntryUpdate> {
   // first let's serialize all of the simple entries (if present!)
@@ -11649,9 +11594,9 @@ declare function* serializeStateUpdate(
   const encode = <T>(codec: Encode<T>, val: T) => Encoder.encodeObject(codec, val, spec);
 
   // then let's proceed with service updates
-  yield* serializeServiceUpdates(update.servicesUpdates, encode);
-  yield* serializePreimages(update.preimages, encode);
-  yield* serializeStorage(update.storage);
+  yield* serializeServiceUpdates(update.servicesUpdates, encode, blake2b);
+  yield* serializePreimages(update.preimages, encode, blake2b);
+  yield* serializeStorage(update.storage, blake2b);
   yield* serializeRemovedServices(update.servicesRemoved);
 }
 
@@ -11663,18 +11608,18 @@ declare function* serializeRemovedServices(servicesRemoved: ServiceId[] | undefi
   }
 }
 
-declare function* serializeStorage(storage: UpdateStorage[] | undefined): Generator<StateEntryUpdate> {
+declare function* serializeStorage(storage: UpdateStorage[] | undefined, blake2b: Blake2b): Generator<StateEntryUpdate> {
   for (const { action, serviceId } of storage ?? []) {
     switch (action.kind) {
       case UpdateStorageKind.Set: {
         const key = action.storage.key;
-        const codec = serialize.serviceStorage(serviceId, key);
+        const codec = serialize.serviceStorage(blake2b, serviceId, key);
         yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
         break;
       }
       case UpdateStorageKind.Remove: {
         const key = action.key;
-        const codec = serialize.serviceStorage(serviceId, key);
+        const codec = serialize.serviceStorage(blake2b, serviceId, key);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
         break;
       }
@@ -11684,16 +11629,20 @@ declare function* serializeStorage(storage: UpdateStorage[] | undefined): Genera
   }
 }
 
-declare function* serializePreimages(preimages: UpdatePreimage[] | undefined, encode: EncodeFun): Generator<StateEntryUpdate> {
+declare function* serializePreimages(
+  preimages: UpdatePreimage[] | undefined,
+  encode: EncodeFun,
+  blake2b: Blake2b,
+): Generator<StateEntryUpdate> {
   for (const { action, serviceId } of preimages ?? []) {
     switch (action.kind) {
       case UpdatePreimageKind.Provide: {
         const { hash, blob } = action.preimage;
-        const codec = serialize.servicePreimages(serviceId, hash);
+        const codec = serialize.servicePreimages(blake2b, serviceId, hash);
         yield [StateEntryUpdateAction.Insert, codec.key, blob];
 
         if (action.slot !== null) {
-          const codec2 = serialize.serviceLookupHistory(serviceId, hash, tryAsU32(blob.length));
+          const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
           yield [
             StateEntryUpdateAction.Insert,
             codec2.key,
@@ -11704,16 +11653,16 @@ declare function* serializePreimages(preimages: UpdatePreimage[] | undefined, en
       }
       case UpdatePreimageKind.UpdateOrAdd: {
         const { hash, length, slots } = action.item;
-        const codec = serialize.serviceLookupHistory(serviceId, hash, length);
+        const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
         yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
         break;
       }
       case UpdatePreimageKind.Remove: {
         const { hash, length } = action;
-        const codec = serialize.servicePreimages(serviceId, hash);
+        const codec = serialize.servicePreimages(blake2b, serviceId, hash);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
 
-        const codec2 = serialize.serviceLookupHistory(serviceId, hash, length);
+        const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
         yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
         break;
       }
@@ -11725,6 +11674,7 @@ declare function* serializePreimages(preimages: UpdatePreimage[] | undefined, en
 declare function* serializeServiceUpdates(
   servicesUpdates: UpdateService[] | undefined,
   encode: EncodeFun,
+  blake2b: Blake2b,
 ): Generator<StateEntryUpdate> {
   for (const { action, serviceId } of servicesUpdates ?? []) {
     // new service being created or updated
@@ -11734,7 +11684,7 @@ declare function* serializeServiceUpdates(
     // additional lookup history update
     if (action.kind === UpdateServiceKind.Create && action.lookupHistory !== null) {
       const { lookupHistory } = action;
-      const codec2 = serialize.serviceLookupHistory(serviceId, lookupHistory.hash, lookupHistory.length);
+      const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
       yield [StateEntryUpdateAction.Insert, codec2.key, encode(codec2.Codec, lookupHistory.slots)];
     }
   }
@@ -11868,8 +11818,8 @@ declare class StateEntries {
   );
 
   /** Turn in-memory state into it's serialized form. */
-  static serializeInMemory(spec: ChainSpec, state: InMemoryState) {
-    return new StateEntries(convertInMemoryStateToDictionary(spec, state));
+  static serializeInMemory(spec: ChainSpec, blake2b: Blake2b, state: InMemoryState) {
+    return new StateEntries(convertInMemoryStateToDictionary(spec, blake2b, state));
   }
 
   /**
@@ -11924,7 +11874,8 @@ declare class StateEntries {
   }
 
   /** https://graypaper.fluffylabs.dev/#/68eaa1f/391600391600?v=0.6.4 */
-  getRootHash(): StateRootHash {
+  getRootHash(blake2b: Blake2b): StateRootHash {
+    const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
     const leaves: SortedSet<LeafNode> = SortedSet.fromArray(leafComparator);
     for (const [key, value] of this) {
       leaves.insert(InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value));
@@ -11937,6 +11888,7 @@ declare class StateEntries {
 /** https://graypaper.fluffylabs.dev/#/68eaa1f/38a50038a500?v=0.6.4 */
 declare function convertInMemoryStateToDictionary(
   spec: ChainSpec,
+  blake2b: Blake2b,
   state: InMemoryState,
 ): TruncatedHashDictionary<StateKey, BytesBlob> {
   const serialized = TruncatedHashDictionary.fromEntries<StateKey, BytesBlob>([]);
@@ -11969,20 +11921,25 @@ declare function convertInMemoryStateToDictionary(
 
     // preimages
     for (const preimage of service.data.preimages.values()) {
-      const { key, Codec } = serialize.servicePreimages(serviceId, preimage.hash);
+      const { key, Codec } = serialize.servicePreimages(blake2b, serviceId, preimage.hash);
       serialized.set(key, Encoder.encodeObject(Codec, preimage.blob));
     }
 
     // storage
     for (const storage of service.data.storage.values()) {
-      const { key, Codec } = serialize.serviceStorage(serviceId, storage.key);
+      const { key, Codec } = serialize.serviceStorage(blake2b, serviceId, storage.key);
       serialized.set(key, Encoder.encodeObject(Codec, storage.value));
     }
 
     // lookup history
     for (const lookupHistoryList of service.data.lookupHistory.values()) {
       for (const lookupHistory of lookupHistoryList) {
-        const { key, Codec } = serialize.serviceLookupHistory(serviceId, lookupHistory.hash, lookupHistory.length);
+        const { key, Codec } = serialize.serviceLookupHistory(
+          blake2b,
+          serviceId,
+          lookupHistory.hash,
+          lookupHistory.length,
+        );
         serialized.set(key, Encoder.encodeObject(Codec, lookupHistory.slots.slice()));
       }
     }
@@ -12013,21 +11970,23 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
   implements State, EnumerableState
 {
   /** Create a state-like object from collection of serialized entries. */
-  static fromStateEntries(spec: ChainSpec, state: StateEntries, recentServices: ServiceId[] = []) {
-    return new SerializedState(spec, state, recentServices);
+  static fromStateEntries(spec: ChainSpec, blake2b: Blake2b, state: StateEntries, recentServices: ServiceId[] = []) {
+    return new SerializedState(spec, blake2b, state, recentServices);
   }
 
   /** Create a state-like object backed by some DB. */
   static new<T extends SerializedStateBackend>(
     spec: ChainSpec,
+    blake2b: Blake2b,
     db: T,
     recentServices: ServiceId[] = [],
   ): SerializedState<T> {
-    return new SerializedState(spec, db, recentServices);
+    return new SerializedState(spec, blake2b, db, recentServices);
   }
 
   private constructor(
     private readonly spec: ChainSpec,
+    private readonly blake2b: Blake2b,
     public backend: T,
     /** Best-effort list of recently active services. */
     private readonly _recentServiceIds: ServiceId[],
@@ -12058,7 +12017,7 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
       this._recentServiceIds.push(id);
     }
 
-    return new SerializedService(id, serviceData, (key) => this.retrieveOptional(key));
+    return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
   }
 
   private retrieve<T>({ key, Codec }: KeyAndCodec<T>, description: string): T {
@@ -12157,6 +12116,7 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
 /** Service data representation on a serialized state. */
 declare class SerializedService implements Service {
   constructor(
+    public readonly blake2b: Blake2b,
     /** Service id */
     public readonly serviceId: ServiceId,
     private readonly accountInfo: ServiceAccountInfo,
@@ -12172,14 +12132,14 @@ declare class SerializedService implements Service {
   getStorage(rawKey: StorageKey): BytesBlob | null {
     if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
       const SERVICE_ID_BYTES = 4;
-      const serviceIdAndKey = new Uint8Array(SERVICE_ID_BYTES + rawKey.length);
+      const serviceIdAndKey = safeAllocUint8Array(SERVICE_ID_BYTES + rawKey.length);
       serviceIdAndKey.set(u32AsLeBytes(this.serviceId));
       serviceIdAndKey.set(rawKey.raw, SERVICE_ID_BYTES);
-      const key: StorageKey = asOpaqueType(BytesBlob.blobFrom(blake2b.hashBytes(serviceIdAndKey).raw));
-      return this.retrieveOptional(serialize.serviceStorage(this.serviceId, key)) ?? null;
+      const key: StorageKey = asOpaqueType(BytesBlob.blobFrom(this.blake2b.hashBytes(serviceIdAndKey).raw));
+      return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, key)) ?? null;
     }
 
-    return this.retrieveOptional(serialize.serviceStorage(this.serviceId, rawKey)) ?? null;
+    return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, rawKey)) ?? null;
   }
 
   /**
@@ -12189,17 +12149,17 @@ declare class SerializedService implements Service {
    */
   hasPreimage(hash: PreimageHash): boolean {
     // TODO [ToDr] consider optimizing to avoid fetching the whole data.
-    return this.retrieveOptional(serialize.servicePreimages(this.serviceId, hash)) !== undefined;
+    return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) !== undefined;
   }
 
   /** Retrieve preimage from the DB. */
   getPreimage(hash: PreimageHash): BytesBlob | null {
-    return this.retrieveOptional(serialize.servicePreimages(this.serviceId, hash)) ?? null;
+    return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) ?? null;
   }
 
   /** Retrieve preimage lookup history. */
   getLookupHistory(hash: PreimageHash, len: U32): LookupHistorySlots | null {
-    const rawSlots = this.retrieveOptional(serialize.serviceLookupHistory(this.serviceId, hash, len));
+    const rawSlots = this.retrieveOptional(serialize.serviceLookupHistory(this.blake2b, this.serviceId, hash, len));
     if (rawSlots === undefined) {
       return null;
     }
@@ -12212,9 +12172,9 @@ type KeyAndCodec<T> = {
   Codec: Decode<T>;
 };
 
-declare function loadState(spec: ChainSpec, entries: Iterable<[StateKey | TruncatedHash, BytesBlob]>) {
+declare function loadState(spec: ChainSpec, blake2b: Blake2b, entries: Iterable<[StateKey | TruncatedHash, BytesBlob]>) {
   const stateEntries = StateEntries.fromEntriesUnsafe(entries);
-  return SerializedState.fromStateEntries(spec, stateEntries);
+  return SerializedState.fromStateEntries(spec, blake2b, stateEntries);
 }
 
 /**
@@ -12370,7 +12330,8 @@ declare class LeafDb implements SerializedStateBackend {
     assertNever(val);
   }
 
-  getStateRoot(): StateRootHash {
+  getStateRoot(blake2b: Blake2b): StateRootHash {
+    const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
     return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leaves).asOpaque();
   }
 
@@ -12468,7 +12429,8 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   }
 
   async getStateRoot(state: InMemoryState): Promise<StateRootHash> {
-    return StateEntries.serializeInMemory(this.spec, state).getRootHash();
+    const blake2b = await Blake2b.createHasher();
+    return StateEntries.serializeInMemory(this.spec, blake2b, state).getRootHash(blake2b);
   }
 
   /** Insert a full state into the database. */
@@ -12573,7 +12535,7 @@ declare function padAndEncodeData(input: BytesBlob) {
   const paddedLength = Math.ceil(input.length / PIECE_SIZE) * PIECE_SIZE;
   let padded = input;
   if (input.length !== paddedLength) {
-    padded = BytesBlob.blobFrom(new Uint8Array(paddedLength));
+    padded = BytesBlob.blobFrom(safeAllocUint8Array(paddedLength));
     padded.raw.set(input.raw, 0);
   }
   return chunkingFunction(padded);
@@ -12629,7 +12591,7 @@ declare function decodeData(input: FixedSizeArray<[number, BytesBlob], N_CHUNKS_
  */
 declare function encodePoints(input: Bytes<PIECE_SIZE>): FixedSizeArray<Bytes<POINT_LENGTH>, N_CHUNKS_TOTAL> {
   const result: Bytes<POINT_LENGTH>[] = [];
-  const data = new Uint8Array(POINT_ALIGNMENT * N_CHUNKS_REQUIRED);
+  const data = safeAllocUint8Array(POINT_ALIGNMENT * N_CHUNKS_REQUIRED);
 
   // add original shards to the result
   for (let i = 0; i < N_CHUNKS_REQUIRED; i++) {
@@ -12649,7 +12611,7 @@ declare function encodePoints(input: Bytes<PIECE_SIZE>): FixedSizeArray<Bytes<PO
   for (let i = 0; i < N_CHUNKS_REDUNDANCY; i++) {
     const pointIndex = i * POINT_ALIGNMENT;
 
-    const redundancyPoint = new Uint8Array(POINT_LENGTH);
+    const redundancyPoint = safeAllocUint8Array(POINT_LENGTH);
     for (let j = 0; j < POINT_LENGTH; j++) {
       redundancyPoint[j] = encodedData[pointIndex + j * HALF_POINT_SIZE];
     }
@@ -12669,7 +12631,7 @@ declare function decodePiece(
 ): Bytes<PIECE_SIZE> {
   const result = Bytes.zero(PIECE_SIZE);
 
-  const data = new Uint8Array(N_CHUNKS_REQUIRED * POINT_ALIGNMENT);
+  const data = safeAllocUint8Array(N_CHUNKS_REQUIRED * POINT_ALIGNMENT);
   const indices = new Uint16Array(input.length);
 
   for (let i = 0; i < N_CHUNKS_REQUIRED; i++) {
@@ -12796,7 +12758,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++) {
@@ -13694,13 +13656,12 @@ 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>;
 
@@ -13869,7 +13830,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)) {
@@ -14013,7 +13974,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);
@@ -18071,9 +18032,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. */
@@ -18086,8 +18053,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;
@@ -18230,7 +18201,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);
 
@@ -18263,8 +18234,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) {
@@ -18291,6 +18264,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();
@@ -18662,7 +18640,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) {
@@ -18671,7 +18649,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;
   }
@@ -18864,10 +18842,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;
@@ -19039,8 +19017,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 });
   },
 );
 
@@ -19541,7 +19518,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 */
@@ -19555,7 +19532,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);
   }
 
   /**
@@ -19569,7 +19546,7 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
       .view()
       .map((g) => g.view())
       .map((guarantee) => {
-        const reportHash = blake2b.hashBytes(guarantee.report.encoded(), this.allocator).asOpaque<WorkReportHash>();
+        const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque<WorkReportHash>();
         return BytesBlob.blobFromParts([
           reportHash.raw,
           guarantee.slot.encoded().raw,
@@ -19579,15 +19556,15 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
 
     const guaranteeBlob = Encoder.encodeObject(codec.sequenceVarLen(dumpCodec), guarantees, this.context);
 
-    const et = blake2b.hashBytes(extrinsicView.tickets.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
-    const ep = blake2b.hashBytes(extrinsicView.preimages.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
-    const eg = blake2b.hashBytes(guaranteeBlob, this.allocator).asOpaque<ExtrinsicHash>();
-    const ea = blake2b.hashBytes(extrinsicView.assurances.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
-    const ed = blake2b.hashBytes(extrinsicView.disputes.encoded(), this.allocator).asOpaque<ExtrinsicHash>();
+    const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque<ExtrinsicHash>();
+    const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque<ExtrinsicHash>();
+    const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque<ExtrinsicHash>();
+    const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque<ExtrinsicHash>();
+    const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque<ExtrinsicHash>();
 
     const encoded = BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);
 
-    return new WithHashAndBytes(blake2b.hashBytes(encoded, this.allocator).asOpaque(), extrinsicView, encoded);
+    return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), extrinsicView, encoded);
   }
 
   /** Creates hash for given WorkPackage */
@@ -19598,7 +19575,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);
   }
 }
 
@@ -19619,7 +19596,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
@@ -19648,7 +19628,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) {
@@ -19679,156 +19659,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;
@@ -19838,10 +19668,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 };
 }