@typeberry/lib 0.0.1-1c07527 → 0.0.1-3d2303d

package/index.d.ts

@@ -59,8 +59,6 @@ declare namespace index$s {
 }
 
 declare enum GpVersion {
-  V0_6_5 = "0.6.5",
-  V0_6_6 = "0.6.6",
   V0_6_7 = "0.6.7",
   V0_7_0 = "0.7.0-preview",
   V0_7_1 = "0.7.1-preview",
@@ -73,13 +71,7 @@ declare enum TestSuite {
 
 declare const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
 
-declare const ALL_VERSIONS_IN_ORDER = [
-  GpVersion.V0_6_5,
-  GpVersion.V0_6_6,
-  GpVersion.V0_6_7,
-  GpVersion.V0_7_0,
-  GpVersion.V0_7_1,
-];
+declare const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1];
 
 declare const env = typeof process === "undefined" ? {} : process.env;
 declare const DEFAULT_VERSION = GpVersion.V0_6_7;
@@ -168,6 +160,10 @@ declare class Compatibility {
   }
 }
 
+declare function isBrowser() {
+  return typeof process === "undefined" || typeof process.abort === "undefined";
+}
+
 /**
  * A function to perform runtime assertions.
  *
@@ -286,20 +282,19 @@ declare function inspect<T>(val: T): string {
 }
 
 /** Utility function to measure time taken for some operation [ms]. */
-declare const measure =
-  typeof process === "undefined"
-    ? (id: string) => {
-        const start = performance.now();
-        return () => `${id} took ${performance.now() - start}ms`;
-      }
-    : (id: string) => {
-        const start = process.hrtime.bigint();
-        return () => {
-          const tookNano = process.hrtime.bigint() - start;
-          const tookMilli = Number(tookNano / 1_000_000n).toFixed(2);
-          return `${id} took ${tookMilli}ms`;
-        };
+declare const measure = isBrowser()
+  ? (id: string) => {
+      const start = performance.now();
+      return () => `${id} took ${performance.now() - start}ms`;
+    }
+  : (id: string) => {
+      const start = process.hrtime.bigint();
+      return () => {
+        const tookNano = process.hrtime.bigint() - start;
+        const tookMilli = Number(tookNano / 1_000_000n).toFixed(2);
+        return `${id} took ${tookMilli}ms`;
       };
+    };
 
 /** A class that adds `toString` method that prints all properties of an object. */
 declare abstract class WithDebug {
@@ -498,6 +493,8 @@ type DeepEqualOptions = {
   errorsCollector?: ErrorsCollector;
 };
 
+declare let oomWarningPrinted = false;
+
 /** Deeply compare `actual` and `expected` values. */
 declare function deepEqual<T>(
   actual: T | undefined,
@@ -530,7 +527,7 @@ declare function deepEqual<T>(
       try {
         assert.strictEqual(actualDisp, expectedDisp, message);
       } catch (e) {
-        if (isOoMWorkaroundNeeded) {
+        if (isOoMWorkaroundNeeded && !oomWarningPrinted) {
           console.warn(
             [
               "Stacktrace may be crappy because of a problem in nodejs.",
@@ -538,6 +535,7 @@ declare function deepEqual<T>(
               "Maybe we do not need it anymore",
             ].join("\n"),
           );
+          oomWarningPrinted = true;
         }
         throw e;
       }
@@ -786,17 +784,19 @@ declare const index$r_ensure: typeof ensure;
 declare const index$r_env: typeof env;
 declare const index$r_getAllKeysSorted: typeof getAllKeysSorted;
 declare const index$r_inspect: typeof inspect;
+declare const index$r_isBrowser: typeof isBrowser;
 declare const index$r_isResult: typeof isResult;
 declare const index$r_isTaggedError: typeof isTaggedError;
 declare const index$r_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
 declare const index$r_measure: typeof measure;
+declare const index$r_oomWarningPrinted: typeof oomWarningPrinted;
 declare const index$r_parseCurrentSuite: typeof parseCurrentSuite;
 declare const index$r_parseCurrentVersion: typeof parseCurrentVersion;
 declare const index$r_resultToString: typeof resultToString;
 declare const index$r_seeThrough: typeof seeThrough;
 declare const index$r_trimStack: typeof trimStack;
 declare namespace index$r {
-  export { index$r_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$r_CURRENT_SUITE as CURRENT_SUITE, index$r_CURRENT_VERSION as CURRENT_VERSION, index$r_Compatibility as Compatibility, index$r_DEFAULT_SUITE as DEFAULT_SUITE, index$r_DEFAULT_VERSION as DEFAULT_VERSION, index$r_ErrorsCollector as ErrorsCollector, index$r_GpVersion as GpVersion, Result$2 as Result, index$r_RichTaggedError as RichTaggedError, index$r_TEST_COMPARE_USING as TEST_COMPARE_USING, index$r_TestSuite as TestSuite, index$r_WithDebug as WithDebug, index$r___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$r_asOpaqueType as asOpaqueType, index$r_assertEmpty as assertEmpty, index$r_assertNever as assertNever, index$r_callCompareFunction as callCompareFunction, index$r_cast as cast, index$r_check as check, index$r_deepEqual as deepEqual, index$r_ensure as ensure, index$r_env as env, index$r_getAllKeysSorted as getAllKeysSorted, index$r_inspect as inspect, index$r_isResult as isResult, index$r_isTaggedError as isTaggedError, index$r_maybeTaggedErrorToString as maybeTaggedErrorToString, index$r_measure as measure, index$r_parseCurrentSuite as parseCurrentSuite, index$r_parseCurrentVersion as parseCurrentVersion, index$r_resultToString as resultToString, index$r_seeThrough as seeThrough, index$r_trimStack as trimStack };
+  export { index$r_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$r_CURRENT_SUITE as CURRENT_SUITE, index$r_CURRENT_VERSION as CURRENT_VERSION, index$r_Compatibility as Compatibility, index$r_DEFAULT_SUITE as DEFAULT_SUITE, index$r_DEFAULT_VERSION as DEFAULT_VERSION, index$r_ErrorsCollector as ErrorsCollector, index$r_GpVersion as GpVersion, Result$2 as Result, index$r_RichTaggedError as RichTaggedError, index$r_TEST_COMPARE_USING as TEST_COMPARE_USING, index$r_TestSuite as TestSuite, index$r_WithDebug as WithDebug, index$r___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$r_asOpaqueType as asOpaqueType, index$r_assertEmpty as assertEmpty, index$r_assertNever as assertNever, index$r_callCompareFunction as callCompareFunction, index$r_cast as cast, index$r_check as check, index$r_deepEqual as deepEqual, index$r_ensure as ensure, index$r_env as env, index$r_getAllKeysSorted as getAllKeysSorted, index$r_inspect as inspect, index$r_isBrowser as isBrowser, index$r_isResult as isResult, index$r_isTaggedError as isTaggedError, index$r_maybeTaggedErrorToString as maybeTaggedErrorToString, index$r_measure as measure, index$r_oomWarningPrinted as oomWarningPrinted, index$r_parseCurrentSuite as parseCurrentSuite, index$r_parseCurrentVersion as parseCurrentVersion, index$r_resultToString as resultToString, index$r_seeThrough as seeThrough, index$r_trimStack as trimStack };
   export type { index$r_DeepEqualOptions as DeepEqualOptions, index$r_EnumMapping as EnumMapping, index$r_ErrorResult as ErrorResult, index$r_OK as OK, index$r_OkResult as OkResult, index$r_Opaque as Opaque, index$r_StringLiteral as StringLiteral, index$r_TaggedError as TaggedError, index$r_TokenOf as TokenOf, index$r_Uninstantiable as Uninstantiable, index$r_WithOpaque as WithOpaque };
 }
 
@@ -2332,6 +2332,141 @@ declare class Skipper {
   }
 }
 
+/** Infer the type that is described by given descriptor `T` */
+type DescribedBy<T> = T extends Descriptor<infer V> ? V : never;
+
+/**
+ * Converts a class `T` into an object with the same fields as the class.
+ */
+type CodecRecord<T> = {
+  [K in PropertyKeys<T>]: T[K];
+};
+
+/**
+ * Same as `CodecRecord<T>`, but the fields are all optional.
+ */
+type OptionalRecord<T> = {
+  [K in PropertyKeys<T>]?: T[K];
+};
+
+/**
+ * `Descriptor` of a complex type of some class with a bunch of public fields.
+ */
+type DescriptorRecord<T> = {
+  [K in PropertyKeys<T>]: Descriptor<T[K], unknown>;
+};
+
+/**
+ * Simplified `DescriptorRecord`, where all keys must be used as descriptor keys.
+ */
+type SimpleDescriptorRecord<T> = {
+  [K in keyof T]: Descriptor<T[K], unknown>;
+};
+
+/** Only keys that contain properties, not methods. */
+type PropertyKeys<T> = {
+  // biome-ignore lint/complexity/noBannedTypes: We want to skip any function-like types here.
+  [K in Extract<keyof T, string>]: T[K] extends Function ? never : K;
+}[Extract<keyof T, string>];
+
+/** A constructor of basic data object that takes a `Record<T>`. */
+type ClassConstructor<T> = {
+  name: string;
+  create: (o: CodecRecord<T>) => T;
+};
+
+/**
+ * A full codec type, i.e. the `Encode` and `Decode`.
+ */
+type Codec<T> = Encode<T> & Decode<T>;
+
+/**
+ * Type descriptor definition.
+ *
+ * The type descriptor can encode & decode given type `T`, but
+ * also have a `name` and a byte-size hint.
+ *
+ * Descriptors can be composed to form more complex typings.
+ */
+declare class Descriptor<T, V = T> implements Codec<T>, Skip {
+  /** A "lightweight" version of the object. */
+  public readonly View: Descriptor<V>;
+
+  /** New descriptor with specialized `View`. */
+  public static withView<T, V>(
+    name: string,
+    sizeHint: SizeHint,
+    encode: Descriptor<T, V>["encode"],
+    decode: Descriptor<T, V>["decode"],
+    skip: Descriptor<T, V>["skip"],
+    view: Descriptor<V>,
+  ) {
+    return new Descriptor(name, sizeHint, encode, decode, skip, view);
+  }
+
+  /** Create a new descriptor without a specialized `View`. */
+  public static new<T>(
+    name: string,
+    sizeHint: SizeHint,
+    encode: Descriptor<T>["encode"],
+    decode: Descriptor<T>["decode"],
+    skip: Descriptor<T>["skip"],
+  ) {
+    return new Descriptor(name, sizeHint, encode, decode, skip, null);
+  }
+
+  private constructor(
+    /** Descriptive name of the coded data. */
+    public readonly name: string,
+    /** A byte size hint for encoded data. */
+    public readonly sizeHint: SizeHint,
+    /** Encoding function. */
+    public readonly encode: (e: Encoder, elem: T) => void,
+    /** Decoding function. */
+    public readonly decode: (d: Decoder) => T,
+    /** Skipping function. */
+    public readonly skip: (s: Skipper) => void,
+    /** view object. It can be `null` iff T===V. */
+    view: Descriptor<V> | null,
+  ) {
+    // We cast here to make sure that the field is always set.
+    this.View = view ?? (this as unknown as Descriptor<V>);
+  }
+
+  /**
+   * Extract an encoded version of this type from the decoder.
+   *
+   * This function skips the object instead of decoding it,
+   * allowing to retrieve the encoded portion of the object from `Decoder`.
+   */
+  public skipEncoded(decoder: Decoder) {
+    const initBytes = decoder.bytesRead();
+    this.skip(new Skipper(decoder));
+    const endBytes = decoder.bytesRead();
+    return BytesBlob.blobFrom(decoder.source.subarray(initBytes, endBytes));
+  }
+
+  /** Return a new descriptor that converts data into some other type. */
+  public convert<F>(input: (i: F) => T, output: (i: T) => F): Descriptor<F, V> {
+    return new Descriptor(
+      this.name,
+      this.sizeHint,
+      (e: Encoder, elem: F) => this.encode(e, input(elem)),
+      (d: Decoder) => output(this.decode(d)),
+      this.skip,
+      this.View,
+    );
+  }
+
+  /** Safely cast the descriptor value to a opaque type. */
+  public asOpaque<R>(): Descriptor<Opaque<T, TokenOf<R, T>>, V> {
+    return this.convert(
+      (i) => seeThrough(i),
+      (o) => asOpaqueType<T, TokenOf<R, T>>(o),
+    );
+  }
+}
+
 type LengthRange = {
   /** Inclusive value of minimal length of the sequence. */
   minLength: number;
@@ -2624,98 +2759,6 @@ declare const TYPICAL_SEQUENCE_LENGTH = 64;
  */
 declare const TYPICAL_DICTIONARY_LENGTH = 32;
 
-/**
- * A full codec type, i.e. the `Encode` and `Decode`.
- */
-type Codec<T> = Encode<T> & Decode<T>;
-
-/**
- * Type descriptor definition.
- *
- * The type descriptor can encode & decode given type `T`, but
- * also have a `name` and a byte-size hint.
- *
- * Descriptors can be composed to form more complex typings.
- */
-declare class Descriptor<T, V = T> implements Codec<T>, Skip {
-  /** A "lightweight" version of the object. */
-  public readonly View: Descriptor<V>;
-
-  /** New descriptor with specialized `View`. */
-  public static withView<T, V>(
-    name: string,
-    sizeHint: SizeHint,
-    encode: Descriptor<T, V>["encode"],
-    decode: Descriptor<T, V>["decode"],
-    skip: Descriptor<T, V>["skip"],
-    view: Descriptor<V>,
-  ) {
-    return new Descriptor(name, sizeHint, encode, decode, skip, view);
-  }
-
-  /** Create a new descriptor without a specialized `View`. */
-  public static new<T>(
-    name: string,
-    sizeHint: SizeHint,
-    encode: Descriptor<T>["encode"],
-    decode: Descriptor<T>["decode"],
-    skip: Descriptor<T>["skip"],
-  ) {
-    return new Descriptor(name, sizeHint, encode, decode, skip, null);
-  }
-
-  private constructor(
-    /** Descriptive name of the coded data. */
-    public readonly name: string,
-    /** A byte size hint for encoded data. */
-    public readonly sizeHint: SizeHint,
-    /** Encoding function. */
-    public readonly encode: (e: Encoder, elem: T) => void,
-    /** Decoding function. */
-    public readonly decode: (d: Decoder) => T,
-    /** Skipping function. */
-    public readonly skip: (s: Skipper) => void,
-    /** view object. It can be `null` iff T===V. */
-    view: Descriptor<V> | null,
-  ) {
-    // We cast here to make sure that the field is always set.
-    this.View = view ?? (this as unknown as Descriptor<V>);
-  }
-
-  /**
-   * Extract an encoded version of this type from the decoder.
-   *
-   * This function skips the object instead of decoding it,
-   * allowing to retrieve the encoded portion of the object from `Decoder`.
-   */
-  public skipEncoded(decoder: Decoder) {
-    const initBytes = decoder.bytesRead();
-    this.skip(new Skipper(decoder));
-    const endBytes = decoder.bytesRead();
-    return BytesBlob.blobFrom(decoder.source.subarray(initBytes, endBytes));
-  }
-
-  /** Return a new descriptor that converts data into some other type. */
-  public convert<F>(input: (i: F) => T, output: (i: T) => F): Descriptor<F, V> {
-    return new Descriptor(
-      this.name,
-      this.sizeHint,
-      (e: Encoder, elem: F) => this.encode(e, input(elem)),
-      (d: Decoder) => output(this.decode(d)),
-      this.skip,
-      this.View,
-    );
-  }
-
-  /** Safely cast the descriptor value to a opaque type. */
-  public asOpaque<R>(): Descriptor<Opaque<T, TokenOf<R, T>>, V> {
-    return this.convert(
-      (i) => seeThrough(i),
-      (o) => asOpaqueType<T, TokenOf<R, T>>(o),
-    );
-  }
-}
-
 /**
  * Convert a descriptor for regular array into readonly one.
  *
@@ -2736,49 +2779,6 @@ declare function readonlyArray<T, V>(desc: Descriptor<T[], V>): Descriptor<reado
   );
 }
 
-/** Infer the type that is described by given descriptor `T` */
-type DescribedBy<T> = T extends Descriptor<infer V> ? V : never;
-
-/**
- * Converts a class `T` into an object with the same fields as the class.
- */
-type CodecRecord<T> = {
-  [K in PropertyKeys<T>]: T[K];
-};
-
-/**
- * Same as `CodecRecord<T>`, but the fields are all optional.
- */
-type OptionalRecord<T> = {
-  [K in PropertyKeys<T>]?: T[K];
-};
-
-/**
- * `Descriptor` of a complex type of some class with a bunch of public fields.
- */
-type DescriptorRecord<T> = {
-  [K in PropertyKeys<T>]: Descriptor<T[K], unknown>;
-};
-
-/**
- * Simplified `DescriptorRecord`, where all keys must be used as descriptor keys.
- */
-type SimpleDescriptorRecord<T> = {
-  [K in keyof T]: Descriptor<T[K], unknown>;
-};
-
-/** Only keys that contain properties, not methods. */
-type PropertyKeys<T> = {
-  // biome-ignore lint/complexity/noBannedTypes: We want to skip any function-like types here.
-  [K in Extract<keyof T, string>]: T[K] extends Function ? never : K;
-}[Extract<keyof T, string>];
-
-/** A constructor of basic data object that takes a `Record<T>`. */
-type ClassConstructor<T> = {
-  name: string;
-  create: (o: CodecRecord<T>) => T;
-};
-
 declare function exactHint(bytes: number): SizeHint {
   return {
     bytes,
@@ -3399,6 +3399,9 @@ type index$o_SimpleDescriptorRecord<T> = SimpleDescriptorRecord<T>;
 type index$o_SizeHint = SizeHint;
 declare const index$o_TYPICAL_DICTIONARY_LENGTH: typeof TYPICAL_DICTIONARY_LENGTH;
 declare const index$o_TYPICAL_SEQUENCE_LENGTH: typeof TYPICAL_SEQUENCE_LENGTH;
+type index$o_ViewField<T, V> = ViewField<T, V>;
+declare const index$o_ViewField: typeof ViewField;
+type index$o_ViewOf<T, D extends DescriptorRecord<T>> = ViewOf<T, D>;
 declare const index$o_addSizeHints: typeof addSizeHints;
 declare const index$o_decodeVariableLengthExtraBytes: typeof decodeVariableLengthExtraBytes;
 declare const index$o_exactHint: typeof exactHint;
@@ -3411,8 +3414,8 @@ declare const index$o_sequenceViewVarLen: typeof sequenceViewVarLen;
 declare const index$o_tryAsExactBytes: typeof tryAsExactBytes;
 declare const index$o_validateLength: typeof validateLength;
 declare namespace index$o {
-  export { index$o_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$o_Decoder as Decoder, index$o_Descriptor as Descriptor, index$o_Encoder as Encoder, index$o_MASKS as MASKS, index$o_MAX_LENGTH as MAX_LENGTH, index$o_ObjectView as ObjectView, index$o_SequenceView as SequenceView, index$o_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$o_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$o_addSizeHints as addSizeHints, codec$1 as codec, index$o_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$o_exactHint as exactHint, index$o_forEachDescriptor as forEachDescriptor, index$o_hasUniqueView as hasUniqueView, index$o_objectView as objectView, index$o_readonlyArray as readonlyArray, index$o_sequenceViewFixLen as sequenceViewFixLen, index$o_sequenceViewVarLen as sequenceViewVarLen, index$o_tryAsExactBytes as tryAsExactBytes, index$o_validateLength as validateLength };
-  export type { index$o_ClassConstructor as ClassConstructor, index$o_Codec as Codec, index$o_CodecRecord as CodecRecord, index$o_Decode as Decode, index$o_DescribedBy as DescribedBy, index$o_DescriptorRecord as DescriptorRecord, index$o_Encode as Encode, index$o_LengthRange as LengthRange, index$o_OptionalRecord as OptionalRecord, Options$1 as Options, index$o_PropertyKeys as PropertyKeys, index$o_SimpleDescriptorRecord as SimpleDescriptorRecord, index$o_SizeHint as SizeHint };
+  export { index$o_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$o_Decoder as Decoder, index$o_Descriptor as Descriptor, index$o_Encoder as Encoder, index$o_MASKS as MASKS, index$o_MAX_LENGTH as MAX_LENGTH, index$o_ObjectView as ObjectView, index$o_SequenceView as SequenceView, index$o_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$o_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$o_ViewField as ViewField, index$o_addSizeHints as addSizeHints, codec$1 as codec, index$o_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$o_exactHint as exactHint, index$o_forEachDescriptor as forEachDescriptor, index$o_hasUniqueView as hasUniqueView, index$o_objectView as objectView, index$o_readonlyArray as readonlyArray, index$o_sequenceViewFixLen as sequenceViewFixLen, index$o_sequenceViewVarLen as sequenceViewVarLen, index$o_tryAsExactBytes as tryAsExactBytes, index$o_validateLength as validateLength };
+  export type { index$o_ClassConstructor as ClassConstructor, index$o_Codec as Codec, index$o_CodecRecord as CodecRecord, index$o_Decode as Decode, index$o_DescribedBy as DescribedBy, index$o_DescriptorRecord as DescriptorRecord, index$o_Encode as Encode, index$o_LengthRange as LengthRange, index$o_OptionalRecord as OptionalRecord, Options$1 as Options, index$o_PropertyKeys as PropertyKeys, index$o_SimpleDescriptorRecord as SimpleDescriptorRecord, index$o_SizeHint as SizeHint, index$o_ViewOf as ViewOf };
 }
 
 /**
@@ -4461,6 +4464,84 @@ declare namespace index$m {
   export type { index$m_HashWithZeroedBit as HashWithZeroedBit, index$m_ImmutableHashDictionary as ImmutableHashDictionary, index$m_ImmutableHashSet as ImmutableHashSet, index$m_ImmutableSortedArray as ImmutableSortedArray, index$m_ImmutableSortedSet as ImmutableSortedSet, index$m_KeyMapper as KeyMapper, index$m_KeyMappers as KeyMappers, index$m_KnownSize as KnownSize, index$m_KnownSizeArray as KnownSizeArray, index$m_KnownSizeId as KnownSizeId, index$m_NestedMaps as NestedMaps };
 }
 
+declare namespace bandersnatch_d_exports {
+  export { batch_verify_tickets, __wbg_init$2 as default, derive_public_key, initSync$2 as initSync, ring_commitment, verify_seal };
+  export type { InitInput$2 as InitInput, InitOutput$2 as InitOutput, SyncInitInput$2 as SyncInitInput };
+}
+/* tslint:disable */
+/* eslint-disable */
+/**
+* @param {Uint8Array} keys
+* @returns {Uint8Array}
+*/
+declare function ring_commitment(keys: Uint8Array): Uint8Array;
+/**
+* Derive Private and Public Key from Seed
+*
+* returns: `Vec<u8>` containing the exit (1 byte) status followed by the (32 bytes) public key
+* @param {Uint8Array} seed
+* @returns {Uint8Array}
+*/
+declare function derive_public_key(seed: Uint8Array): Uint8Array;
+/**
+* Seal verification as defined in:
+* https://graypaper.fluffylabs.dev/#/68eaa1f/0eff000eff00?v=0.6.4
+* or
+* https://graypaper.fluffylabs.dev/#/68eaa1f/0e54010e5401?v=0.6.4
+* @param {Uint8Array} keys
+* @param {number} signer_key_index
+* @param {Uint8Array} seal_data
+* @param {Uint8Array} payload
+* @param {Uint8Array} aux_data
+* @returns {Uint8Array}
+*/
+declare function verify_seal(keys: Uint8Array, signer_key_index: number, seal_data: Uint8Array, payload: Uint8Array, aux_data: Uint8Array): Uint8Array;
+/**
+* Verify multiple tickets at once as defined in:
+* https://graypaper.fluffylabs.dev/#/68eaa1f/0f3e000f3e00?v=0.6.4
+*
+* NOTE: the aux_data of VRF function is empty!
+* @param {Uint8Array} keys
+* @param {Uint8Array} tickets_data
+* @param {number} vrf_input_data_len
+* @returns {Uint8Array}
+*/
+declare function batch_verify_tickets(keys: Uint8Array, tickets_data: Uint8Array, vrf_input_data_len: number): Uint8Array;
+type InitInput$2 = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+interface InitOutput$2 {
+  readonly memory: WebAssembly.Memory;
+  readonly ring_commitment: (a: number, b: number, c: number) => void;
+  readonly derive_public_key: (a: number, b: number, c: number) => void;
+  readonly verify_seal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly batch_verify_tickets: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+}
+type SyncInitInput$2 = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {SyncInitInput} module
+*
+* @returns {InitOutput}
+*/
+declare function initSync$2(module: SyncInitInput$2): InitOutput$2;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {InitInput | Promise<InitInput>} module_or_path
+*
+* @returns {Promise<InitOutput>}
+*/
+declare function __wbg_init$2(module_or_path?: InitInput$2 | Promise<InitInput$2>): Promise<InitOutput$2>;
+//#endregion
+//#region native/index.d.ts
+declare function initAll(): Promise<void>;
+
 /** ED25519 private key size. */
 declare const ED25519_PRIV_KEY_BYTES = 32;
 type ED25519_PRIV_KEY_BYTES = typeof ED25519_PRIV_KEY_BYTES;
@@ -4553,7 +4634,7 @@ declare async function verify<T extends BytesBlob>(input: Input<T>[]): Promise<b
     offset += messageLength;
   }
 
-  const result = Array.from(verify_ed25519(data)).map((x) => x === 1);
+  const result = Array.from(ed25519.verify_ed25519(data)).map((x) => x === 1);
   return Promise.resolve(result);
 }
 
@@ -4575,7 +4656,7 @@ declare async function verifyBatch<T extends BytesBlob>(input: Input<T>[]): Prom
 
   const data = BytesBlob.blobFromParts(first, ...rest).raw;
 
-  return Promise.resolve(verify_ed25519_batch(data));
+  return Promise.resolve(ed25519.verify_ed25519_batch(data));
 }
 
 type ed25519_ED25519_KEY_BYTES = ED25519_KEY_BYTES;
@@ -4595,59 +4676,6 @@ declare namespace ed25519 {
   export type { ed25519_ED25519_KEY_BYTES as ED25519_KEY_BYTES, ed25519_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, ed25519_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, ed25519_Ed25519Key as Ed25519Key, ed25519_Ed25519Signature as Ed25519Signature, ed25519_Input as Input };
 }
 
-/* tslint:disable */
-/* eslint-disable */
-/**
-* @param {Uint8Array} keys
-* @returns {Uint8Array}
-*/
-declare function ring_commitment(keys: Uint8Array): Uint8Array;
-/**
-* Derive Private and Public Key from Seed
-*
-* returns: `Vec<u8>` containing the exit (1 byte) status followed by the (32 bytes) public key
-* @param {Uint8Array} seed
-* @returns {Uint8Array}
-*/
-declare function derive_public_key(seed: Uint8Array): Uint8Array;
-/**
-* Seal verification as defined in:
-* https://graypaper.fluffylabs.dev/#/68eaa1f/0eff000eff00?v=0.6.4
-* or
-* https://graypaper.fluffylabs.dev/#/68eaa1f/0e54010e5401?v=0.6.4
-* @param {Uint8Array} keys
-* @param {number} signer_key_index
-* @param {Uint8Array} seal_data
-* @param {Uint8Array} payload
-* @param {Uint8Array} aux_data
-* @returns {Uint8Array}
-*/
-declare function verify_seal(keys: Uint8Array, signer_key_index: number, seal_data: Uint8Array, payload: Uint8Array, aux_data: Uint8Array): Uint8Array;
-/**
-* Verify multiple tickets at once as defined in:
-* https://graypaper.fluffylabs.dev/#/68eaa1f/0f3e000f3e00?v=0.6.4
-*
-* NOTE: the aux_data of VRF function is empty!
-* @param {Uint8Array} keys
-* @param {Uint8Array} tickets_data
-* @param {number} vrf_input_data_len
-* @returns {Uint8Array}
-*/
-declare function batch_verify_tickets(keys: Uint8Array, tickets_data: Uint8Array, vrf_input_data_len: number): Uint8Array;
-
-declare const bandersnatch_d_batch_verify_tickets: typeof batch_verify_tickets;
-declare const bandersnatch_d_derive_public_key: typeof derive_public_key;
-declare const bandersnatch_d_ring_commitment: typeof ring_commitment;
-declare const bandersnatch_d_verify_seal: typeof verify_seal;
-declare namespace bandersnatch_d {
-  export {
-    bandersnatch_d_batch_verify_tickets as batch_verify_tickets,
-    bandersnatch_d_derive_public_key as derive_public_key,
-    bandersnatch_d_ring_commitment as ring_commitment,
-    bandersnatch_d_verify_seal as verify_seal,
-  };
-}
-
 /** Bandersnatch public key size. */
 declare const BANDERSNATCH_KEY_BYTES = 32;
 type BANDERSNATCH_KEY_BYTES = typeof BANDERSNATCH_KEY_BYTES;
@@ -4705,7 +4733,7 @@ type BlsKey = Opaque<Bytes<BLS_KEY_BYTES>, "BlsKey">;
 
 /** Derive a Bandersnatch public key from a seed. */
 declare function publicKey(seed: Uint8Array): BandersnatchKey {
-  const key = derive_public_key(seed);
+  const key = bandersnatch.derive_public_key(seed);
 
   check(key[0] === 0, "Invalid Bandersnatch public key derived from seed");
 
@@ -4831,7 +4859,7 @@ declare const index$l_bandersnatch: typeof bandersnatch;
 declare const index$l_ed25519: typeof ed25519;
 declare const index$l_keyDerivation: typeof keyDerivation;
 declare namespace index$l {
-  export { index$l_Ed25519Pair as Ed25519Pair, index$l_bandersnatch as bandersnatch, bandersnatch_d as bandersnatchWasm, index$l_ed25519 as ed25519, index$l_keyDerivation as keyDerivation };
+  export { index$l_Ed25519Pair as Ed25519Pair, index$l_bandersnatch as bandersnatch, bandersnatch_d_exports as bandersnatchWasm, index$l_ed25519 as ed25519, initAll as initWasm, index$l_keyDerivation as keyDerivation };
   export type { index$l_BANDERSNATCH_KEY_BYTES as BANDERSNATCH_KEY_BYTES, index$l_BANDERSNATCH_PROOF_BYTES as BANDERSNATCH_PROOF_BYTES, index$l_BANDERSNATCH_RING_ROOT_BYTES as BANDERSNATCH_RING_ROOT_BYTES, index$l_BANDERSNATCH_VRF_SIGNATURE_BYTES as BANDERSNATCH_VRF_SIGNATURE_BYTES, index$l_BLS_KEY_BYTES as BLS_KEY_BYTES, index$l_BandersnatchKey as BandersnatchKey, index$l_BandersnatchProof as BandersnatchProof, index$l_BandersnatchRingRoot as BandersnatchRingRoot, index$l_BandersnatchSecretSeed as BandersnatchSecretSeed, index$l_BandersnatchVrfSignature as BandersnatchVrfSignature, index$l_BlsKey as BlsKey, index$l_ED25519_KEY_BYTES as ED25519_KEY_BYTES, index$l_ED25519_PRIV_KEY_BYTES as ED25519_PRIV_KEY_BYTES, index$l_ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES, index$l_Ed25519Key as Ed25519Key, index$l_Ed25519SecretSeed as Ed25519SecretSeed, index$l_Ed25519Signature as Ed25519Signature, KeySeed as PublicKeySeed, index$l_SEED_SIZE as SEED_SIZE };
 }
 
@@ -5550,6 +5578,39 @@ declare namespace disputes {
  */
 type BeefyHash = Opaque<OpaqueHash, "BeefyHash">;
 
+/** Authorizer hash. */
+type AuthorizerHash = Opaque<OpaqueHash, "AuthorizerHash">;
+
+/** Blake2B hash of a work package. */
+type WorkPackageHash = Opaque<OpaqueHash, "WorkPackageHash">;
+
+/** Work package exported segments merkle root hash. */
+type ExportsRootHash = Opaque<OpaqueHash, "ExportsRootHash">;
+
+/**
+ * Mapping between work package hash and root hash of it's exports.
+ *
+ * Used to construct a dictionary.
+ */
+declare class WorkPackageInfo extends WithDebug {
+  static Codec = codec.Class(WorkPackageInfo, {
+    workPackageHash: codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>(),
+    segmentTreeRoot: codec.bytes(HASH_SIZE).asOpaque<ExportsRootHash>(),
+  });
+
+  private constructor(
+    /** Hash of the described work package. */
+    readonly workPackageHash: WorkPackageHash,
+    /** Exports root hash. */
+    readonly segmentTreeRoot: ExportsRootHash,
+  ) {
+    super();
+  }
+
+  static create({ workPackageHash, segmentTreeRoot }: CodecRecord<WorkPackageInfo>) {
+    return new WorkPackageInfo(workPackageHash, segmentTreeRoot);
+  }
+}
 /**
  * `X`: Refinement Context - state of the chain at the point
  * that the report's corresponding work-package was evaluated.
@@ -5595,12 +5656,17 @@ declare class RefineContext extends WithDebug {
   }
 }
 
+type refineContext_AuthorizerHash = AuthorizerHash;
 type refineContext_BeefyHash = BeefyHash;
+type refineContext_ExportsRootHash = ExportsRootHash;
 type refineContext_RefineContext = RefineContext;
 declare const refineContext_RefineContext: typeof RefineContext;
+type refineContext_WorkPackageHash = WorkPackageHash;
+type refineContext_WorkPackageInfo = WorkPackageInfo;
+declare const refineContext_WorkPackageInfo: typeof WorkPackageInfo;
 declare namespace refineContext {
-  export { refineContext_RefineContext as RefineContext };
-  export type { refineContext_BeefyHash as BeefyHash };
+  export { refineContext_RefineContext as RefineContext, refineContext_WorkPackageInfo as WorkPackageInfo };
+  export type { refineContext_AuthorizerHash as AuthorizerHash, refineContext_BeefyHash as BeefyHash, refineContext_ExportsRootHash as ExportsRootHash, refineContext_WorkPackageHash as WorkPackageHash };
 }
 
 /** `W_E`: The basic size of erasure-coded pieces in octets. See equation H.6. */
@@ -5925,17 +5991,13 @@ declare enum WorkExecResultKind {
   /** `☇`: unexpected program termination. */
   panic = 2,
   /** `⊚`: the number of exports made was invalidly reported. */
-  // biome-ignore lint/style/useLiteralEnumMembers: Compatibility
-  incorrectNumberOfExports = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) ? 3 : -1,
+  incorrectNumberOfExports = 3,
   /** `⊖`: the size of the digest (refinement output) would cross the acceptable limit. */
-  // biome-ignore lint/style/useLiteralEnumMembers: Compatibility
-  digestTooBig = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) ? 4 : -1,
+  digestTooBig = 4,
   /** `BAD`: service code was not available for lookup in state. */
-  // biome-ignore lint/style/useLiteralEnumMembers: Compatibility
-  badCode = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) ? 5 : 3,
+  badCode = 5,
   /** `BIG`: the code was too big (beyond the maximum allowed size `W_C`) */
-  // biome-ignore lint/style/useLiteralEnumMembers: Compatibility
-  codeOversize = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) ? 6 : 4,
+  codeOversize = 6,
 }
 
 /** The execution result of some work-package. */
@@ -6093,14 +6155,6 @@ declare namespace workResult {
   };
 }
 
-/** Authorizer hash. */
-type AuthorizerHash = Opaque<OpaqueHash, "AuthorizerHash">;
-
-/** Blake2B hash of a work package. */
-type WorkPackageHash = Opaque<OpaqueHash, "WorkPackageHash">;
-/** Work package exported segments merkle root hash. */
-type ExportsRootHash = Opaque<OpaqueHash, "ExportsRootHash">;
-
 /**
  * Details about the work package being reported on.
  *
@@ -6135,31 +6189,6 @@ declare class WorkPackageSpec extends WithDebug {
   }
 }
 
-/**
- * Mapping between work package hash and root hash of it's exports.
- *
- * Used to construct a dictionary.
- */
-declare class WorkPackageInfo extends WithDebug {
-  static Codec = codec.Class(WorkPackageInfo, {
-    workPackageHash: codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>(),
-    segmentTreeRoot: codec.bytes(HASH_SIZE).asOpaque<ExportsRootHash>(),
-  });
-
-  private constructor(
-    /** Hash of the described work package. */
-    readonly workPackageHash: WorkPackageHash,
-    /** Exports root hash. */
-    readonly segmentTreeRoot: ExportsRootHash,
-  ) {
-    super();
-  }
-
-  static create({ workPackageHash, segmentTreeRoot }: CodecRecord<WorkPackageInfo>) {
-    return new WorkPackageInfo(workPackageHash, segmentTreeRoot);
-  }
-}
-
 /**
  * A report of execution of some work package.
  *
@@ -6238,18 +6267,15 @@ declare const WorkReportCodec = codec.Class(WorkReportNoCodec, {
 declare const WorkReportCodecPre070 = codec.Class(WorkReportNoCodec, {
   workPackageSpec: WorkPackageSpec.Codec,
   context: RefineContext.Codec,
-  coreIndex:
-    Compatibility.isGreaterOrEqual(GpVersion.V0_6_5) && !Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_5)
-      ? codec.varU32.convert(
-          (o) => tryAsU32(o),
-          (i) => {
-            if (!isU16(i)) {
-              throw new Error(`Core index exceeds U16: ${i}`);
-            }
-            return tryAsCoreIndex(i);
-          },
-        )
-      : codec.u16.asOpaque<CoreIndex>(),
+  coreIndex: codec.varU32.convert(
+    (o) => tryAsU32(o),
+    (i) => {
+      if (!isU16(i)) {
+        throw new Error(`Core index exceeds U16: ${i}`);
+      }
+      return tryAsCoreIndex(i);
+    },
+  ),
   authorizerHash: codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(),
   authorizationOutput: codec.blob,
   segmentRootLookup: readonlyArray(codec.sequenceVarLen(WorkPackageInfo.Codec)),
@@ -6266,11 +6292,6 @@ declare class WorkReport extends WorkReportNoCodec {
     : WorkReportCodecPre070;
 }
 
-type workReport_AuthorizerHash = AuthorizerHash;
-type workReport_ExportsRootHash = ExportsRootHash;
-type workReport_WorkPackageHash = WorkPackageHash;
-type workReport_WorkPackageInfo = WorkPackageInfo;
-declare const workReport_WorkPackageInfo: typeof WorkPackageInfo;
 type workReport_WorkPackageSpec = WorkPackageSpec;
 declare const workReport_WorkPackageSpec: typeof WorkPackageSpec;
 type workReport_WorkReport = WorkReport;
@@ -6280,8 +6301,13 @@ declare const workReport_WorkReportCodecPre070: typeof WorkReportCodecPre070;
 type workReport_WorkReportNoCodec = WorkReportNoCodec;
 declare const workReport_WorkReportNoCodec: typeof WorkReportNoCodec;
 declare namespace workReport {
-  export { workReport_WorkPackageInfo as WorkPackageInfo, workReport_WorkPackageSpec as WorkPackageSpec, workReport_WorkReport as WorkReport, workReport_WorkReportCodec as WorkReportCodec, workReport_WorkReportCodecPre070 as WorkReportCodecPre070, workReport_WorkReportNoCodec as WorkReportNoCodec };
-  export type { workReport_AuthorizerHash as AuthorizerHash, workReport_ExportsRootHash as ExportsRootHash, workReport_WorkPackageHash as WorkPackageHash };
+  export {
+    workReport_WorkPackageSpec as WorkPackageSpec,
+    workReport_WorkReport as WorkReport,
+    workReport_WorkReportCodec as WorkReportCodec,
+    workReport_WorkReportCodecPre070 as WorkReportCodecPre070,
+    workReport_WorkReportNoCodec as WorkReportNoCodec,
+  };
 }
 
 /**
@@ -7827,7 +7853,7 @@ declare const DEV_CONFIG = "dev";
 declare const DEFAULT_CONFIG = "default";
 
 declare const NODE_DEFAULTS = {
-  name: os.hostname(),
+  name: isBrowser() ? "browser" : os.hostname(),
   config: DEFAULT_CONFIG,
 };
 
@@ -7882,11 +7908,11 @@ declare class NodeConfiguration {
 
 declare function loadConfig(configPath: string): NodeConfiguration {
   if (configPath === DEFAULT_CONFIG) {
-    return parseFromJson(defaultConfigJson, NodeConfiguration.fromJson);
+    return parseFromJson(configs.default, NodeConfiguration.fromJson);
   }
 
   if (configPath === DEV_CONFIG) {
-    return parseFromJson(devConfigJson, NodeConfiguration.fromJson);
+    return parseFromJson(configs.dev, NodeConfiguration.fromJson);
   }
 
   try {
@@ -8227,20 +8253,7 @@ declare class AutoAccumulate {
 declare class PrivilegedServices {
   static Codec = codec.Class(PrivilegedServices, {
     manager: codec.u32.asOpaque<ServiceId>(),
-    authManager: Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-      ? codecPerCore(codec.u32.asOpaque<ServiceId>())
-      : codecWithContext((ctx) =>
-          codec.u32.asOpaque<ServiceId>().convert(
-            // NOTE: [MaSo] In a compatibility mode we are always updating all entries
-            // (all the entries are the same)
-            // so it doesn't matter which one we take here.
-            (perCore: PerCore<ServiceId>) => perCore[0],
-            (serviceId: ServiceId) => {
-              const array = new Array(ctx.coresCount).fill(serviceId);
-              return tryAsPerCore(array, ctx);
-            },
-          ),
-        ),
+    authManager: codecPerCore(codec.u32.asOpaque<ServiceId>()),
     validatorsManager: codec.u32.asOpaque<ServiceId>(),
     autoAccumulateServices: readonlyArray(codec.sequenceVarLen(AutoAccumulate.Codec)),
   });
@@ -8407,85 +8420,31 @@ declare class Mountain<H extends OpaqueHash> {
     return Mountain.fromChildren(hasher, [this, other]);
   }
 
-  toString() {
-    return `${this.size} @ ${this.peak}`;
-  }
-}
-
-type index$f_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$f_MerkleMountainRange: typeof MerkleMountainRange;
-type index$f_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$f_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-type index$f_Mountain<H extends OpaqueHash> = Mountain<H>;
-declare const index$f_Mountain: typeof Mountain;
-declare const index$f_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
-declare namespace index$f {
-  export { index$f_MerkleMountainRange as MerkleMountainRange, index$f_Mountain as Mountain, index$f_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
-  export type { index$f_MmrHasher as MmrHasher, index$f_MmrPeaks as MmrPeaks };
-}
-
-/**
- * `H = 8`: The size of recent history, in blocks.
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
- */
-declare const MAX_RECENT_HISTORY = 8;
-type MAX_RECENT_HISTORY = typeof MAX_RECENT_HISTORY;
-
-type LegacyBlocksState = KnownSizeArray<LegacyBlockState, `0..${typeof MAX_RECENT_HISTORY}`>;
-
-declare class LegacyBlockState extends WithDebug {
-  static Codec = codec.Class(LegacyBlockState, {
-    headerHash: codec.bytes(HASH_SIZE).asOpaque<HeaderHash>(),
-    mmr: codec.object({
-      peaks: readonlyArray(codec.sequenceVarLen(codec.optional(codec.bytes(HASH_SIZE)))),
-    }),
-    postStateRoot: codec.bytes(HASH_SIZE).asOpaque<StateRootHash>(),
-    reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
-  });
-
-  static create({ headerHash, mmr, postStateRoot, reported }: CodecRecord<LegacyBlockState>) {
-    return new LegacyBlockState(headerHash, mmr, postStateRoot, reported);
-  }
-
-  private constructor(
-    /** Header hash. */
-    public readonly headerHash: HeaderHash,
-    /** Merkle mountain range peaks. */
-    public readonly mmr: MmrPeaks<KeccakHash>,
-    /** Posterior state root filled in with a 1-block delay. */
-    public postStateRoot: StateRootHash,
-    /** Reported work packages (no more than number of cores). */
-    public readonly reported: HashDictionary<WorkPackageHash, WorkPackageInfo>,
-  ) {
-    super();
-  }
-}
-
-declare class LegacyRecentBlocks extends WithDebug {
-  static Codec = codec.Class(LegacyRecentBlocks, {
-    blocks: codecKnownSizeArray(LegacyBlockState.Codec, {
-      minLength: 0,
-      maxLength: MAX_RECENT_HISTORY,
-      typicalLength: MAX_RECENT_HISTORY,
-    }),
-  });
-
-  static create(a: CodecRecord<LegacyRecentBlocks>) {
-    return new LegacyRecentBlocks(a.blocks);
-  }
-
-  private constructor(
-    /**
-     * Most recent blocks.
-     * https://graypaper.fluffylabs.dev/#/85129da/0fb6010fb601?v=0.6.3
-     */
-    public readonly blocks: LegacyBlocksState,
-  ) {
-    super();
+  toString() {
+    return `${this.size} @ ${this.peak}`;
   }
 }
 
+type index$f_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const index$f_MerkleMountainRange: typeof MerkleMountainRange;
+type index$f_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type index$f_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+type index$f_Mountain<H extends OpaqueHash> = Mountain<H>;
+declare const index$f_Mountain: typeof Mountain;
+declare const index$f_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
+declare namespace index$f {
+  export { index$f_MerkleMountainRange as MerkleMountainRange, index$f_Mountain as Mountain, index$f_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
+  export type { index$f_MmrHasher as MmrHasher, index$f_MmrPeaks as MmrPeaks };
+}
+
+/**
+ * `H = 8`: The size of recent history, in blocks.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
+ */
+declare const MAX_RECENT_HISTORY = 8;
+type MAX_RECENT_HISTORY = typeof MAX_RECENT_HISTORY;
+
 /** Array of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
 type BlocksState = KnownSizeArray<BlockState, `0..${typeof MAX_RECENT_HISTORY}`>;
 
@@ -8549,87 +8508,54 @@ declare class RecentBlocks extends WithDebug {
 }
 
 /**
- * Unified recent history of blocks that handles both legacy and current formats.
+ * Recent history of blocks.
  *
- * https://graypaper.fluffylabs.dev/#/85129da/38cb0138cb01?v=0.6.3
  * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
  */
 declare class RecentBlocksHistory extends WithDebug {
   static Codec = Descriptor.new<RecentBlocksHistory>(
     "RecentBlocksHistory",
-    Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) ? RecentBlocks.Codec.sizeHint : LegacyRecentBlocks.Codec.sizeHint,
-    (encoder, value) =>
-      Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-        ? RecentBlocks.Codec.encode(encoder, value.asCurrent())
-        : LegacyRecentBlocks.Codec.encode(encoder, value.asLegacy()),
+    RecentBlocks.Codec.sizeHint,
+    (encoder, value) => RecentBlocks.Codec.encode(encoder, value.asCurrent()),
     (decoder) => {
-      if (Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)) {
-        const recentBlocks = RecentBlocks.Codec.decode(decoder);
-        return RecentBlocksHistory.create(recentBlocks);
-      }
-      const legacyBlocks = LegacyRecentBlocks.Codec.decode(decoder);
-      return RecentBlocksHistory.legacyCreate(legacyBlocks);
+      const recentBlocks = RecentBlocks.Codec.decode(decoder);
+      return RecentBlocksHistory.create(recentBlocks);
     },
-    (_sizer) => {
-      return Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-        ? RecentBlocks.Codec.sizeHint
-        : LegacyRecentBlocks.Codec.sizeHint;
+    (skip) => {
+      return RecentBlocks.Codec.skip(skip);
     },
   );
 
   static create(recentBlocks: RecentBlocks) {
-    return new RecentBlocksHistory(recentBlocks, null);
-  }
-
-  static legacyCreate(legacyRecentBlocks: LegacyRecentBlocks) {
-    return new RecentBlocksHistory(null, legacyRecentBlocks);
+    return new RecentBlocksHistory(recentBlocks);
   }
 
   static empty() {
-    if (Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)) {
-      return RecentBlocksHistory.create(
-        RecentBlocks.create({
-          blocks: asKnownSize([]),
-          accumulationLog: { peaks: [] },
-        }),
-      );
-    }
-    return RecentBlocksHistory.legacyCreate(LegacyRecentBlocks.create({ blocks: asKnownSize([]) }));
+    return RecentBlocksHistory.create(
+      RecentBlocks.create({
+        blocks: asKnownSize([]),
+        accumulationLog: { peaks: [] },
+      }),
+    );
   }
 
   /**
    * Returns the block's BEEFY super peak.
-   *
-   * NOTE: The `hasher` parameter exists solely for backward compatibility with legacy block format.
    */
-  static accumulationResult(
-    block: BlockState | LegacyBlockState,
-    {
-      hasher,
-    }: {
-      hasher: MmrHasher<KeccakHash>;
-    },
-  ): KeccakHash {
-    return Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-      ? (block as BlockState).accumulationResult
-      : MerkleMountainRange.fromPeaks(hasher, (block as LegacyBlockState).mmr).getSuperPeakHash();
+  static accumulationResult(block: BlockState): KeccakHash {
+    return (block as BlockState).accumulationResult;
   }
 
-  private constructor(
-    private readonly current: RecentBlocks | null,
-    private readonly legacy: LegacyRecentBlocks | null,
-  ) {
+  private constructor(private readonly current: RecentBlocks | null) {
     super();
   }
 
   /** History of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
-  get blocks(): readonly (BlockState | LegacyBlockState)[] {
-    if (Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) && this.current !== null) {
+  get blocks(): readonly BlockState[] {
+    if (this.current !== null) {
       return this.current.blocks;
     }
-    if (this.legacy !== null) {
-      return this.legacy.blocks;
-    }
+
     throw new Error("RecentBlocksHistory is in invalid state");
   }
 
@@ -8640,15 +8566,8 @@ declare class RecentBlocksHistory extends WithDebug {
     return this.current;
   }
 
-  asLegacy() {
-    if (this.legacy === null) {
-      throw new Error("Cannot access legacy RecentBlocks format");
-    }
-    return this.legacy;
-  }
-
-  updateBlocks(blocks: (BlockState | LegacyBlockState)[]): RecentBlocksHistory {
-    if (Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) && this.current !== null) {
+  updateBlocks(blocks: BlockState[]): RecentBlocksHistory {
+    if (this.current !== null) {
       return RecentBlocksHistory.create(
         RecentBlocks.create({
           ...this.current,
@@ -8656,13 +8575,7 @@ declare class RecentBlocksHistory extends WithDebug {
         }),
       );
     }
-    if (this.legacy !== null) {
-      return RecentBlocksHistory.legacyCreate(
-        LegacyRecentBlocks.create({
-          blocks: asOpaqueType(blocks as LegacyBlockState[]),
-        }),
-      );
-    }
+
     throw new Error("RecentBlocksHistory is in invalid state. Cannot be updated!");
   }
 }
@@ -8850,31 +8763,18 @@ declare const ignoreValueWithDefault = <T>(defaultValue: T) =>
  * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
  */
 declare class ServiceAccountInfo extends WithDebug {
-  static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-    ? codec.Class(ServiceAccountInfo, {
-        codeHash: codec.bytes(HASH_SIZE).asOpaque<CodeHash>(),
-        balance: codec.u64,
-        accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: codec.u64,
-        gratisStorage: codec.u64,
-        storageUtilisationCount: codec.u32,
-        created: codec.u32.convert((x) => x, tryAsTimeSlot),
-        lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
-        parentService: codec.u32.convert((x) => x, tryAsServiceId),
-      })
-    : codec.Class(ServiceAccountInfo, {
-        codeHash: codec.bytes(HASH_SIZE).asOpaque<CodeHash>(),
-        balance: codec.u64,
-        accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: codec.u64,
-        storageUtilisationCount: codec.u32,
-        gratisStorage: ignoreValueWithDefault(tryAsU64(0)),
-        created: ignoreValueWithDefault(tryAsTimeSlot(0)),
-        lastAccumulation: ignoreValueWithDefault(tryAsTimeSlot(0)),
-        parentService: ignoreValueWithDefault(tryAsServiceId(0)),
-      });
+  static Codec = codec.Class(ServiceAccountInfo, {
+    codeHash: codec.bytes(HASH_SIZE).asOpaque<CodeHash>(),
+    balance: codec.u64,
+    accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+    onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+    storageUtilisationBytes: codec.u64,
+    gratisStorage: codec.u64,
+    storageUtilisationCount: codec.u32,
+    created: codec.u32.convert((x) => x, tryAsTimeSlot),
+    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
+    parentService: codec.u32.convert((x) => x, tryAsServiceId),
+  });
 
   static create(a: CodecRecord<ServiceAccountInfo>) {
     return new ServiceAccountInfo(
@@ -8896,11 +8796,6 @@ declare class ServiceAccountInfo extends WithDebug {
    * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
    */
   static calculateThresholdBalance(items: U32, bytes: U64, gratisStorage: U64): U64 {
-    check(
-      gratisStorage === tryAsU64(0) || Compatibility.isGreaterOrEqual(GpVersion.V0_6_7),
-      "Gratis storage cannot be non-zero before 0.6.7",
-    );
-
     const storageCost =
       BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
 
@@ -9211,9 +9106,7 @@ type ServicesUpdate = {
 };
 
 declare const codecServiceId: Descriptor<ServiceId> =
-  Compatibility.isSuite(TestSuite.W3F_DAVXY) ||
-  Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_5) ||
-  Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
+  Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
     ? codec.u32.asOpaque<ServiceId>()
     : codec.varU32.convert(
         (s) => tryAsU32(s),
@@ -10255,11 +10148,6 @@ declare const index$e_InMemoryService: typeof InMemoryService;
 type index$e_InMemoryState = InMemoryState;
 declare const index$e_InMemoryState: typeof InMemoryState;
 type index$e_InMemoryStateFields = InMemoryStateFields;
-type index$e_LegacyBlockState = LegacyBlockState;
-declare const index$e_LegacyBlockState: typeof LegacyBlockState;
-type index$e_LegacyBlocksState = LegacyBlocksState;
-type index$e_LegacyRecentBlocks = LegacyRecentBlocks;
-declare const index$e_LegacyRecentBlocks: typeof LegacyRecentBlocks;
 type index$e_LookupHistoryItem = LookupHistoryItem;
 declare const index$e_LookupHistoryItem: typeof LookupHistoryItem;
 type index$e_LookupHistorySlots = LookupHistorySlots;
@@ -10330,8 +10218,8 @@ 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_LegacyBlockState as LegacyBlockState, index$e_LegacyRecentBlocks as LegacyRecentBlocks, 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_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_LegacyBlocksState as LegacyBlocksState, 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_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_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 };
 }
 
 type StateKey$1 = Opaque<OpaqueHash, "stateKey">;
@@ -10475,7 +10363,7 @@ type StateCodec<T> = {
 
 /** Serialization for particular state entries. */
 declare namespace serialize {
-  /** C(1): https://graypaper.fluffylabs.dev/#/85129da/38a20138a201?v=0.6.3 */
+  /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
   export const authPools: StateCodec<State["authPools"]> = {
     key: stateKeys.index(StateKeyIdx.Alpha),
     Codec: codecPerCore(
@@ -10488,7 +10376,7 @@ declare namespace serialize {
     extract: (s) => s.authPools,
   };
 
-  /** C(2): https://graypaper.fluffylabs.dev/#/85129da/38be0138be01?v=0.6.3 */
+  /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
   export const authQueues: StateCodec<State["authQueues"]> = {
     key: stateKeys.index(StateKeyIdx.Phi),
     Codec: codecPerCore(
@@ -10499,7 +10387,6 @@ declare namespace serialize {
 
   /**
    * C(3): Recent blocks with compatibility
-   *  https://graypaper.fluffylabs.dev/#/85129da/38cb0138cb01?v=0.6.3
    *  https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e013b3e01?v=0.6.7
    */
   export const recentBlocks: StateCodec<State["recentBlocks"]> = {
@@ -10508,7 +10395,7 @@ declare namespace serialize {
     extract: (s) => s.recentBlocks,
   };
 
-  /** C(4): https://graypaper.fluffylabs.dev/#/85129da/38e60138e601?v=0.6.3 */
+  /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
   export const safrole: StateCodec<SafroleData> = {
     key: stateKeys.index(StateKeyIdx.Gamma),
     Codec: SafroleData.Codec,
@@ -10521,63 +10408,63 @@ declare namespace serialize {
       }),
   };
 
-  /** C(5): https://graypaper.fluffylabs.dev/#/85129da/383d02383d02?v=0.6.3 */
+  /** C(5): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bba013bba01?v=0.6.7 */
   export const disputesRecords: StateCodec<State["disputesRecords"]> = {
     key: stateKeys.index(StateKeyIdx.Psi),
     Codec: DisputesRecords.Codec,
     extract: (s) => s.disputesRecords,
   };
 
-  /** C(6): https://graypaper.fluffylabs.dev/#/85129da/387602387602?v=0.6.3 */
+  /** C(6): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bf3013bf301?v=0.6.7 */
   export const entropy: StateCodec<State["entropy"]> = {
     key: stateKeys.index(StateKeyIdx.Eta),
     Codec: codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque<EntropyHash>(), ENTROPY_ENTRIES),
     extract: (s) => s.entropy,
   };
 
-  /** C(7): https://graypaper.fluffylabs.dev/#/85129da/388302388302?v=0.6.3 */
+  /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
   export const designatedValidators: StateCodec<State["designatedValidatorData"]> = {
     key: stateKeys.index(StateKeyIdx.Iota),
     Codec: codecPerValidator(ValidatorData.Codec),
     extract: (s) => s.designatedValidatorData,
   };
 
-  /** C(8): https://graypaper.fluffylabs.dev/#/85129da/389002389002?v=0.6.3 */
+  /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
   export const currentValidators: StateCodec<State["currentValidatorData"]> = {
     key: stateKeys.index(StateKeyIdx.Kappa),
     Codec: codecPerValidator(ValidatorData.Codec),
     extract: (s) => s.currentValidatorData,
   };
 
-  /** C(9): https://graypaper.fluffylabs.dev/#/85129da/389d02389d02?v=0.6.3 */
+  /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
   export const previousValidators: StateCodec<State["previousValidatorData"]> = {
     key: stateKeys.index(StateKeyIdx.Lambda),
     Codec: codecPerValidator(ValidatorData.Codec),
     extract: (s) => s.previousValidatorData,
   };
 
-  /** C(10): https://graypaper.fluffylabs.dev/#/85129da/38aa0238aa02?v=0.6.3 */
+  /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
   export const availabilityAssignment: StateCodec<State["availabilityAssignment"]> = {
     key: stateKeys.index(StateKeyIdx.Rho),
     Codec: codecPerCore(codec.optional(AvailabilityAssignment.Codec)),
     extract: (s) => s.availabilityAssignment,
   };
 
-  /** C(11): https://graypaper.fluffylabs.dev/#/85129da/38c10238c102?v=0.6.3 */
+  /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
   export const timeslot: StateCodec<State["timeslot"]> = {
     key: stateKeys.index(StateKeyIdx.Tau),
     Codec: codec.u32.asOpaque<TimeSlot>(),
     extract: (s) => s.timeslot,
   };
 
-  /** C(12): https://graypaper.fluffylabs.dev/#/85129da/38cf0238cf02?v=0.6.3 */
+  /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
   export const privilegedServices: StateCodec<State["privilegedServices"]> = {
     key: stateKeys.index(StateKeyIdx.Chi),
     Codec: PrivilegedServices.Codec,
     extract: (s) => s.privilegedServices,
   };
 
-  /** C(13): https://graypaper.fluffylabs.dev/#/85129da/38e10238e102?v=0.6.3 */
+  /** C(13): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b5e023b5e02?v=0.6.7 */
   export const statistics: StateCodec<State["statistics"]> = {
     key: stateKeys.index(StateKeyIdx.Pi),
     Codec: StatisticsData.Codec,
@@ -10591,7 +10478,7 @@ declare namespace serialize {
     extract: (s) => s.accumulationQueue,
   };
 
-  /** C(15): https://graypaper.fluffylabs.dev/#/85129da/381903381903?v=0.6.3 */
+  /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
   export const recentlyAccumulated: StateCodec<State["recentlyAccumulated"]> = {
     key: stateKeys.index(StateKeyIdx.Xi),
     Codec: codecPerEpochBlock(
@@ -10687,27 +10574,17 @@ declare function* serializeRemovedServices(servicesRemoved: ServiceId[] | undefi
   }
 }
 
-declare function getLegacyKey(serviceId: ServiceId, rawKey: StorageKey): StorageKey {
-  const SERVICE_ID_BYTES = 4;
-  const serviceIdAndKey = new Uint8Array(SERVICE_ID_BYTES + rawKey.length);
-  serviceIdAndKey.set(u32AsLeBytes(serviceId));
-  serviceIdAndKey.set(rawKey.raw, SERVICE_ID_BYTES);
-  return asOpaqueType(BytesBlob.blobFrom(blake2b.hashBytes(serviceIdAndKey).raw));
-}
-
 declare function* serializeStorage(storage: UpdateStorage[] | undefined): Generator<StateEntryUpdate> {
   for (const { action, serviceId } of storage ?? []) {
     switch (action.kind) {
       case UpdateStorageKind.Set: {
-        const key = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-          ? action.storage.key
-          : getLegacyKey(serviceId, action.storage.key);
+        const key = action.storage.key;
         const codec = serialize.serviceStorage(serviceId, key);
         yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
         break;
       }
       case UpdateStorageKind.Remove: {
-        const key = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) ? action.key : getLegacyKey(serviceId, action.key);
+        const key = action.key;
         const codec = serialize.serviceStorage(serviceId, key);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
         break;
@@ -10847,7 +10724,7 @@ declare function* serializeBasicKeys(spec: ChainSpec, update: Partial<State>) {
     yield doSerialize(update.recentlyAccumulated, serialize.recentlyAccumulated); // C(15)
   }
 
-  if (update.accumulationOutputLog !== undefined && Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)) {
+  if (update.accumulationOutputLog !== undefined) {
     yield doSerialize(update.accumulationOutputLog, serialize.accumulationOutputLog); // C(16)
   }
 }
@@ -11642,9 +11519,7 @@ declare function convertInMemoryStateToDictionary(
   doSerialize(serialize.statistics); // C(13)
   doSerialize(serialize.accumulationQueue); // C(14)
   doSerialize(serialize.recentlyAccumulated); // C(15)
-  if (Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)) {
-    doSerialize(serialize.accumulationOutputLog); // C(16)
-  }
+  doSerialize(serialize.accumulationOutputLog); // C(16)
 
   // services
   for (const [serviceId, service] of state.services.entries()) {
@@ -11835,10 +11710,7 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
   }
 
   get accumulationOutputLog(): State["accumulationOutputLog"] {
-    if (Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)) {
-      return this.retrieve(serialize.accumulationOutputLog, "accumulationOutputLog");
-    }
-    return [];
+    return this.retrieve(serialize.accumulationOutputLog, "accumulationOutputLog");
   }
 }
 
@@ -11985,7 +11857,6 @@ declare const index$c_U32_BYTES: typeof U32_BYTES;
 declare const index$c_binaryMerkleization: typeof binaryMerkleization;
 declare const index$c_convertInMemoryStateToDictionary: typeof convertInMemoryStateToDictionary;
 declare const index$c_dumpCodec: typeof dumpCodec;
-declare const index$c_getLegacyKey: typeof getLegacyKey;
 declare const index$c_getSafroleData: typeof getSafroleData;
 declare const index$c_legacyServiceNested: typeof legacyServiceNested;
 declare const index$c_loadState: typeof loadState;
@@ -11999,7 +11870,7 @@ declare const index$c_serializeStorage: typeof serializeStorage;
 declare const index$c_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
 import index$c_stateKeys = stateKeys;
 declare namespace index$c {
-  export { index$c_EMPTY_BLOB as EMPTY_BLOB, index$c_SerializedService as SerializedService, index$c_SerializedState as SerializedState, index$c_StateEntries as StateEntries, index$c_StateEntryUpdateAction as StateEntryUpdateAction, index$c_StateKeyIdx as StateKeyIdx, index$c_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$c_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$c_U32_BYTES as U32_BYTES, index$c_binaryMerkleization as binaryMerkleization, index$c_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$c_dumpCodec as dumpCodec, index$c_getLegacyKey as getLegacyKey, index$c_getSafroleData as getSafroleData, index$c_legacyServiceNested as legacyServiceNested, index$c_loadState as loadState, index$c_serialize as serialize, index$c_serializeBasicKeys as serializeBasicKeys, index$c_serializePreimages as serializePreimages, index$c_serializeRemovedServices as serializeRemovedServices, index$c_serializeServiceUpdates as serializeServiceUpdates, index$c_serializeStateUpdate as serializeStateUpdate, index$c_serializeStorage as serializeStorage, index$c_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$c_stateKeys as stateKeys };
+  export { index$c_EMPTY_BLOB as EMPTY_BLOB, index$c_SerializedService as SerializedService, index$c_SerializedState as SerializedState, index$c_StateEntries as StateEntries, index$c_StateEntryUpdateAction as StateEntryUpdateAction, index$c_StateKeyIdx as StateKeyIdx, index$c_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$c_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$c_U32_BYTES as U32_BYTES, index$c_binaryMerkleization as binaryMerkleization, index$c_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$c_dumpCodec as dumpCodec, index$c_getSafroleData as getSafroleData, index$c_legacyServiceNested as legacyServiceNested, index$c_loadState as loadState, index$c_serialize as serialize, index$c_serializeBasicKeys as serializeBasicKeys, index$c_serializePreimages as serializePreimages, index$c_serializeRemovedServices as serializeRemovedServices, index$c_serializeServiceUpdates as serializeServiceUpdates, index$c_serializeStateUpdate as serializeStateUpdate, index$c_serializeStorage as serializeStorage, index$c_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$c_stateKeys as stateKeys };
   export type { index$c_EncodeFun as EncodeFun, index$c_KeyAndCodec as KeyAndCodec, index$c_SerializedStateBackend as SerializedStateBackend, index$c_StateCodec as StateCodec, index$c_StateEntryUpdate as StateEntryUpdate, StateKey$1 as StateKey };
 }
 
@@ -12359,8 +12230,8 @@ declare function encodePoints(input: Bytes<PIECE_SIZE>): FixedSizeArray<Bytes<PO
   }
 
   // encode and add redundancy shards
-  const points = new ShardsCollection(POINT_ALIGNMENT, data);
-  const encodedResult = encode(N_CHUNKS_REDUNDANCY, POINT_ALIGNMENT, points);
+  const points = new reedSolomon.ShardsCollection(POINT_ALIGNMENT, data);
+  const encodedResult = reedSolomon.encode(N_CHUNKS_REDUNDANCY, points);
   const encodedData = encodedResult.take_data();
 
   for (let i = 0; i < N_CHUNKS_REDUNDANCY; i++) {
@@ -12402,9 +12273,9 @@ declare function decodePiece(
       result.raw.set(points.raw, pointStartInResult);
     }
   }
-  const points = new ShardsCollection(POINT_ALIGNMENT, data, indices);
+  const points = new reedSolomon.ShardsCollection(POINT_ALIGNMENT, data, indices);
 
-  const decodingResult = decode(N_CHUNKS_REQUIRED, N_CHUNKS_REDUNDANCY, POINT_ALIGNMENT, points);
+  const decodingResult = reedSolomon.decode(N_CHUNKS_REQUIRED, N_CHUNKS_REDUNDANCY, points);
   const resultIndices = decodingResult.take_indices(); // it has to be called before take_data
   const resultData = decodingResult.take_data(); // it destroys the result object in rust
 
@@ -12622,77 +12493,249 @@ declare function chunksToShards(
 ): PerValidator<BytesBlob> {
   const result = new Array<BytesBlob>();
 
-  const allChunks = BytesBlob.blobFromParts(chunks.map((c) => c.raw));
-  const shardSize = allChunks.length / N_CHUNKS_TOTAL;
+  const allChunks = BytesBlob.blobFromParts(chunks.map((c) => c.raw));
+  const shardSize = allChunks.length / N_CHUNKS_TOTAL;
+
+  // wrap around the data to have enough
+  const bytesToDrawFrom = BytesBlob.blobFromParts(allChunks.raw, allChunks.raw);
+  const bytesPerValidator = Math.ceil(allChunks.length / spec.validatorsCount);
+  // align number of bytes to the shard length.
+  const alignedBytesPerValidator = Math.ceil(bytesPerValidator / shardSize) * shardSize;
+
+  for (let i = 0; i < spec.validatorsCount; i++) {
+    const start = i * alignedBytesPerValidator;
+    const end = start + alignedBytesPerValidator;
+
+    result.push(BytesBlob.blobFrom(bytesToDrawFrom.raw.subarray(start, end)));
+  }
+
+  return tryAsPerValidator(result, spec);
+}
+
+declare const initEc = async () => {
+  await init.reedSolomon();
+};
+
+declare const index$a_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
+declare const index$a_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
+type index$a_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
+type index$a_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
+type index$a_PIECE_SIZE = PIECE_SIZE;
+declare const index$a_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
+type index$a_POINT_LENGTH = POINT_LENGTH;
+declare const index$a_chunkingFunction: typeof chunkingFunction;
+declare const index$a_chunksToShards: typeof chunksToShards;
+declare const index$a_decodeData: typeof decodeData;
+declare const index$a_decodeDataAndTrim: typeof decodeDataAndTrim;
+declare const index$a_decodePiece: typeof decodePiece;
+declare const index$a_encodePoints: typeof encodePoints;
+declare const index$a_initEc: typeof initEc;
+declare const index$a_join: typeof join;
+declare const index$a_lace: typeof lace;
+declare const index$a_padAndEncodeData: typeof padAndEncodeData;
+declare const index$a_shardsToChunks: typeof shardsToChunks;
+declare const index$a_split: typeof split;
+declare const index$a_transpose: typeof transpose;
+declare const index$a_unzip: typeof unzip;
+declare namespace index$a {
+  export { index$a_HALF_POINT_SIZE as HALF_POINT_SIZE, index$a_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$a_POINT_ALIGNMENT as POINT_ALIGNMENT, index$a_chunkingFunction as chunkingFunction, index$a_chunksToShards as chunksToShards, index$a_decodeData as decodeData, index$a_decodeDataAndTrim as decodeDataAndTrim, index$a_decodePiece as decodePiece, index$a_encodePoints as encodePoints, index$a_initEc as initEc, index$a_join as join, index$a_lace as lace, index$a_padAndEncodeData as padAndEncodeData, index$a_shardsToChunks as shardsToChunks, index$a_split as split, index$a_transpose as transpose, index$a_unzip as unzip };
+  export type { index$a_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$a_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$a_PIECE_SIZE as PIECE_SIZE, index$a_POINT_LENGTH as POINT_LENGTH };
+}
+
+/**
+ * Host call result constants.
+ *
+ * https://graypaper.fluffylabs.dev/#/85129da/2c7c022c7c02?v=0.6.3
+ */
+declare const HostCallResult = {
+  /** The return value indicating an item does not exist. */
+  NONE: tryAsU64(0xffff_ffff_ffff_ffffn), // 2**64 - 1
+  /** Name unknown. */
+  WHAT: tryAsU64(0xffff_ffff_ffff_fffen), // 2**64 - 2
+  /** The inner PVM memory index provided for reading/writing is not accessible. */
+  OOB: tryAsU64(0xffff_ffff_ffff_fffdn), // 2**64 - 3
+  /** Index unknown. */
+  WHO: tryAsU64(0xffff_ffff_ffff_fffcn), // 2**64 - 4
+  /** Storage full. */
+  FULL: tryAsU64(0xffff_ffff_ffff_fffbn), // 2**64 - 5
+  /** Core index unknown. */
+  CORE: tryAsU64(0xffff_ffff_ffff_fffan), // 2**64 - 6
+  /** Insufficient funds. */
+  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. */
+  HUH: tryAsU64(0xffff_ffff_ffff_fff7n), // 2**64 - 9
+  /** The return value indicating general success. */
+  OK: tryAsU64(0n),
+} as const;
+
+declare enum Level {
+  INSANE = 1,
+  TRACE = 2,
+  LOG = 3,
+  INFO = 4,
+  WARN = 5,
+  ERROR = 6,
+}
+
+type Options = {
+  defaultLevel: Level;
+  workingDir: string;
+  modules: Map<string, Level>;
+};
+
+/**
+ * A function to parse logger definition (including modules) given as a string.
+ *
+ * Examples
+ *  - `info` - setup default logging level to `info`.
+ *  - `trace` - default logging level set to `trace`.
+ *  - `debug;consensus=trace` - default level is set to `debug/log`, but consensus is in trace mode.
+ */
+declare function parseLoggerOptions(input: string, defaultLevel: Level, workingDir?: string): Options {
+  const modules = new Map<string, Level>();
+  const parts = input.toLowerCase().split(",");
+  let defLevel = defaultLevel;
+
+  for (const p of parts) {
+    const clean = p.trim();
+    // skip empty objects (forgotten `,` removed)
+    if (clean.length === 0) {
+      continue;
+    }
+    // we just have the default level
+    if (clean.includes("=")) {
+      const [mod, lvl] = clean.split("=");
+      modules.set(mod.trim(), parseLevel(lvl.trim()));
+    } else {
+      defLevel = parseLevel(clean);
+    }
+  }
+
+  // TODO [ToDr] Fix dirname for workers.
+  const myDir = (import.meta.dirname ?? "").split("/");
+  myDir.pop();
+  myDir.pop();
+  return {
+    defaultLevel: defLevel,
+    modules,
+    workingDir: workingDir ?? myDir.join("/"),
+  };
+}
+
+declare const GLOBAL_CONFIG = {
+  options: DEFAULT_OPTIONS,
+  transport: ConsoleTransport.create(DEFAULT_OPTIONS.defaultLevel, DEFAULT_OPTIONS),
+};
+
+/**
+ * A logger instance.
+ */
+declare class Logger {
+  /**
+   * Create a new logger instance given filename and an optional module name.
+   *
+   * If the module name is not given, `fileName` becomes the module name.
+   * The module name can be composed from multiple parts separated with `/`.
+   *
+   * The logger will use a global configuration which can be changed using
+   * [`configureLogger`] function.
+   */
+  static new(fileName?: string, moduleName?: string) {
+    const fName = fileName ?? "unknown";
+    return new Logger(moduleName ?? fName, fName, GLOBAL_CONFIG);
+  }
+
+  /**
+   * Return currently configured level for given module. */
+  static getLevel(moduleName: string): Level {
+    return findLevel(GLOBAL_CONFIG.options, moduleName);
+  }
+
+  /**
+   * Global configuration of all loggers.
+   *
+   * One can specify a default logging level (only logs with level >= default will be printed).
+   * It's also possible to configure per-module logging level that takes precedence
+   * over the default one.
+   *
+   * Changing the options affects all previously created loggers.
+   */
+  static configureAllFromOptions(options: Options) {
+    // find minimal level to optimise logging in case
+    // we don't care about low-level logs.
+    const minimalLevel = Array.from(options.modules.values()).reduce((level, modLevel) => {
+      return level < modLevel ? level : modLevel;
+    }, options.defaultLevel);
+
+    const transport = ConsoleTransport.create(minimalLevel, options);
+
+    // set the global config
+    GLOBAL_CONFIG.options = options;
+    GLOBAL_CONFIG.transport = transport;
+  }
+
+  /**
+   * Global configuration of all loggers.
+   *
+   * Parse configuration options from an input string typically obtained
+   * from environment variable `JAM_LOG`.
+   */
+  static configureAll(input: string, defaultLevel: Level, workingDir?: string) {
+    const options = parseLoggerOptions(input, defaultLevel, workingDir);
+    Logger.configureAllFromOptions(options);
+  }
+
+  constructor(
+    private readonly moduleName: string,
+    private readonly fileName: string,
+    private readonly config: typeof GLOBAL_CONFIG,
+  ) {}
+
+  /** Log a message with `INSANE` level. */
+  insane(val: string) {
+    this.config.transport.insane(this.moduleName, val);
+  }
 
-  // wrap around the data to have enough
-  const bytesToDrawFrom = BytesBlob.blobFromParts(allChunks.raw, allChunks.raw);
-  const bytesPerValidator = Math.ceil(allChunks.length / spec.validatorsCount);
-  // align number of bytes to the shard length.
-  const alignedBytesPerValidator = Math.ceil(bytesPerValidator / shardSize) * shardSize;
+  /** Log a message with `TRACE` level. */
+  trace(val: string) {
+    this.config.transport.trace(this.moduleName, val);
+  }
 
-  for (let i = 0; i < spec.validatorsCount; i++) {
-    const start = i * alignedBytesPerValidator;
-    const end = start + alignedBytesPerValidator;
+  /** Log a message with `DEBUG`/`LOG` level. */
+  log(val: string) {
+    this.config.transport.log(this.moduleName, val);
+  }
 
-    result.push(BytesBlob.blobFrom(bytesToDrawFrom.raw.subarray(start, end)));
+  /** Log a message with `INFO` level. */
+  info(val: string) {
+    this.config.transport.info(this.moduleName, val);
   }
 
-  return tryAsPerValidator(result, spec);
-}
+  /** Log a message with `WARN` level. */
+  warn(val: string) {
+    this.config.transport.warn(this.moduleName, val);
+  }
 
-declare const index$a_HALF_POINT_SIZE: typeof HALF_POINT_SIZE;
-declare const index$a_N_CHUNKS_REDUNDANCY: typeof N_CHUNKS_REDUNDANCY;
-type index$a_N_CHUNKS_REQUIRED = N_CHUNKS_REQUIRED;
-type index$a_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
-type index$a_PIECE_SIZE = PIECE_SIZE;
-declare const index$a_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
-type index$a_POINT_LENGTH = POINT_LENGTH;
-declare const index$a_chunkingFunction: typeof chunkingFunction;
-declare const index$a_chunksToShards: typeof chunksToShards;
-declare const index$a_decodeData: typeof decodeData;
-declare const index$a_decodeDataAndTrim: typeof decodeDataAndTrim;
-declare const index$a_decodePiece: typeof decodePiece;
-declare const index$a_encodePoints: typeof encodePoints;
-declare const index$a_join: typeof join;
-declare const index$a_lace: typeof lace;
-declare const index$a_padAndEncodeData: typeof padAndEncodeData;
-declare const index$a_shardsToChunks: typeof shardsToChunks;
-declare const index$a_split: typeof split;
-declare const index$a_transpose: typeof transpose;
-declare const index$a_unzip: typeof unzip;
-declare namespace index$a {
-  export { index$a_HALF_POINT_SIZE as HALF_POINT_SIZE, index$a_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$a_POINT_ALIGNMENT as POINT_ALIGNMENT, index$a_chunkingFunction as chunkingFunction, index$a_chunksToShards as chunksToShards, index$a_decodeData as decodeData, index$a_decodeDataAndTrim as decodeDataAndTrim, index$a_decodePiece as decodePiece, index$a_encodePoints as encodePoints, index$a_join as join, index$a_lace as lace, index$a_padAndEncodeData as padAndEncodeData, index$a_shardsToChunks as shardsToChunks, index$a_split as split, index$a_transpose as transpose, index$a_unzip as unzip };
-  export type { index$a_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$a_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$a_PIECE_SIZE as PIECE_SIZE, index$a_POINT_LENGTH as POINT_LENGTH };
+  /** Log a message with `ERROR` level. */
+  error(val: string) {
+    this.config.transport.error(this.moduleName, val);
+  }
 }
 
-/**
- * Host call result constants.
- *
- * https://graypaper.fluffylabs.dev/#/85129da/2c7c022c7c02?v=0.6.3
- */
-declare const HostCallResult = {
-  /** The return value indicating an item does not exist. */
-  NONE: tryAsU64(0xffff_ffff_ffff_ffffn), // 2**64 - 1
-  /** Name unknown. */
-  WHAT: tryAsU64(0xffff_ffff_ffff_fffen), // 2**64 - 2
-  /** The inner PVM memory index provided for reading/writing is not accessible. */
-  OOB: tryAsU64(0xffff_ffff_ffff_fffdn), // 2**64 - 3
-  /** Index unknown. */
-  WHO: tryAsU64(0xffff_ffff_ffff_fffcn), // 2**64 - 4
-  /** Storage full. */
-  FULL: tryAsU64(0xffff_ffff_ffff_fffbn), // 2**64 - 5
-  /** Core index unknown. */
-  CORE: tryAsU64(0xffff_ffff_ffff_fffan), // 2**64 - 6
-  /** Insufficient funds. */
-  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. */
-  HUH: tryAsU64(0xffff_ffff_ffff_fff7n), // 2**64 - 9
-  /** The return value indicating general success. */
-  OK: tryAsU64(0n),
-} as const;
+type index$9_Level = Level;
+declare const index$9_Level: typeof Level;
+type index$9_Logger = Logger;
+declare const index$9_Logger: typeof Logger;
+declare const index$9_parseLoggerOptions: typeof parseLoggerOptions;
+declare namespace index$9 {
+  export {
+    index$9_Level as Level,
+    index$9_Logger as Logger,
+    index$9_parseLoggerOptions as parseLoggerOptions,
+  };
+}
 
 /**
  * Mask class is an implementation of skip function defined in GP.
@@ -13953,13 +13996,14 @@ declare abstract class MemoryPage {
  * And then a new version of TypeScript is released.
  */
 declare global {
-  interface ArrayBufferConstructor {
-    new (length: number, options?: { maxByteLength: number }): ArrayBuffer;
-  }
-
-  interface ArrayBuffer {
-    resize(length: number): void;
-  }
+    interface ArrayBufferConstructor {
+        new (length: number, options?: {
+            maxByteLength: number;
+        }): ArrayBuffer;
+    }
+    interface ArrayBuffer {
+        resize(length: number): void;
+    }
 }
 
 type InitialMemoryState = {
@@ -13972,6 +14016,7 @@ declare enum AccessType {
   READ = 0,
   WRITE = 1,
 }
+
 declare class Memory {
   static fromInitialMemory(initialMemoryState: InitialMemoryState) {
     return new Memory(
@@ -14008,6 +14053,7 @@ declare class Memory {
       return Result.ok(OK);
     }
 
+    logger.insane(`MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`);
     const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
 
     if (pagesResult.isError) {
@@ -14096,6 +14142,7 @@ declare class Memory {
       bytesLeft -= bytesToRead;
     }
 
+    logger.insane(`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`);
     return Result.ok(OK);
   }
 
@@ -15095,6 +15142,10 @@ declare class JumpTable {
     return new JumpTable(0, new Uint8Array());
   }
 
+  getSize() {
+    return this.indices.length;
+  }
+
   copyFrom(jt: JumpTable) {
     this.indices = jt.indices;
   }
@@ -15956,207 +16007,46 @@ declare class NoArgsDispatcher {
 
 declare class TwoRegsTwoImmsDispatcher {
   constructor(
-    private loadOps: LoadOps,
-    private dynamicJumpOps: DynamicJumpOps,
-  ) {}
-
-  dispatch(instruction: Instruction, args: TwoRegistersTwoImmediatesArgs) {
-    switch (instruction) {
-      case Instruction.LOAD_IMM_JUMP_IND: {
-        const address = this.dynamicJumpOps.caluclateJumpAddress(args.secondImmediateDecoder, args.secondRegisterIndex);
-        this.loadOps.loadImmediate(args.firstRegisterIndex, args.firstImmediateDecoder);
-        this.dynamicJumpOps.jumpInd(address);
-        break;
-      }
-    }
-  }
-}
-
-declare class OneImmDispatcher {
-  constructor(private hostCallOps: HostCallOps) {}
-
-  dispatch(instruction: Instruction, args: OneImmediateArgs) {
-    switch (instruction) {
-      case Instruction.ECALLI:
-        this.hostCallOps.hostCall(args.immediateDecoder);
-        break;
-    }
-  }
-}
-
-declare class OneRegOneExtImmDispatcher {
-  constructor(private loadOps: LoadOps) {}
-
-  dispatch(instruction: Instruction, args: OneRegisterOneExtendedWidthImmediateArgs) {
-    switch (instruction) {
-      case Instruction.LOAD_IMM_64:
-        this.loadOps.loadImmediateU64(args.registerIndex, args.immediateDecoder);
-        break;
-    }
-  }
-}
-
-declare enum Level {
-  TRACE = 1,
-  LOG = 2,
-  INFO = 3,
-  WARN = 4,
-  ERROR = 5,
-}
-
-type Options = {
-  defaultLevel: Level;
-  workingDir: string;
-  modules: Map<string, Level>;
-};
-
-/**
- * A function to parse logger definition (including modules) given as a string.
- *
- * Examples
- *  - `info` - setup default logging level to `info`.
- *  - `trace` - default logging level set to `trace`.
- *  - `debug;consensus=trace` - default level is set to `debug/log`, but consensus is in trace mode.
- */
-declare function parseLoggerOptions(input: string, defaultLevel: Level, workingDir?: string): Options {
-  const modules = new Map<string, Level>();
-  const parts = input.toLowerCase().split(",");
-  let defLevel = defaultLevel;
-
-  for (const p of parts) {
-    const clean = p.trim();
-    // skip empty objects (forgotten `,` removed)
-    if (clean.length === 0) {
-      continue;
-    }
-    // we just have the default level
-    if (clean.includes("=")) {
-      const [mod, lvl] = clean.split("=");
-      modules.set(mod.trim(), parseLevel(lvl.trim()));
-    } else {
-      defLevel = parseLevel(clean);
-    }
-  }
-
-  // TODO [ToDr] Fix dirname for workers.
-  const myDir = (import.meta.dirname ?? "").split("/");
-  myDir.pop();
-  myDir.pop();
-  return {
-    defaultLevel: defLevel,
-    modules,
-    workingDir: workingDir ?? myDir.join("/"),
-  };
-}
-
-declare const GLOBAL_CONFIG = {
-  options: DEFAULT_OPTIONS,
-  transport: ConsoleTransport.create(DEFAULT_OPTIONS.defaultLevel, DEFAULT_OPTIONS),
-};
-
-/**
- * A logger instance.
- */
-declare class Logger {
-  /**
-   * Create a new logger instance given filename and an optional module name.
-   *
-   * If the module name is not given, `fileName` becomes the module name.
-   * The module name can be composed from multiple parts separated with `/`.
-   *
-   * The logger will use a global configuration which can be changed using
-   * [`configureLogger`] function.
-   */
-  static new(fileName?: string, moduleName?: string) {
-    const fName = fileName ?? "unknown";
-    return new Logger(moduleName ?? fName, fName, GLOBAL_CONFIG);
-  }
-
-  /**
-   * Return currently configured level for given module. */
-  static getLevel(moduleName: string): Level {
-    return findLevel(GLOBAL_CONFIG.options, moduleName);
-  }
-
-  /**
-   * Global configuration of all loggers.
-   *
-   * One can specify a default logging level (only logs with level >= default will be printed).
-   * It's also possible to configure per-module logging level that takes precedence
-   * over the default one.
-   *
-   * Changing the options affects all previously created loggers.
-   */
-  static configureAllFromOptions(options: Options) {
-    // find minimal level to optimise logging in case
-    // we don't care about low-level logs.
-    const minimalLevel = Array.from(options.modules.values()).reduce((level, modLevel) => {
-      return level < modLevel ? level : modLevel;
-    }, options.defaultLevel);
-
-    const transport = ConsoleTransport.create(minimalLevel, options);
-
-    // set the global config
-    GLOBAL_CONFIG.options = options;
-    GLOBAL_CONFIG.transport = transport;
-  }
-
-  /**
-   * Global configuration of all loggers.
-   *
-   * Parse configuration options from an input string typically obtained
-   * from environment variable `JAM_LOG`.
-   */
-  static configureAll(input: string, defaultLevel: Level, workingDir?: string) {
-    const options = parseLoggerOptions(input, defaultLevel, workingDir);
-    Logger.configureAllFromOptions(options);
-  }
-
-  constructor(
-    private readonly moduleName: string,
-    private readonly fileName: string,
-    private readonly config: typeof GLOBAL_CONFIG,
+    private loadOps: LoadOps,
+    private dynamicJumpOps: DynamicJumpOps,
   ) {}
 
-  /** Log a message with `TRACE` level. */
-  trace(val: string) {
-    this.config.transport.trace(this.moduleName, this.fileName, val);
+  dispatch(instruction: Instruction, args: TwoRegistersTwoImmediatesArgs) {
+    switch (instruction) {
+      case Instruction.LOAD_IMM_JUMP_IND: {
+        const address = this.dynamicJumpOps.caluclateJumpAddress(args.secondImmediateDecoder, args.secondRegisterIndex);
+        this.loadOps.loadImmediate(args.firstRegisterIndex, args.firstImmediateDecoder);
+        this.dynamicJumpOps.jumpInd(address);
+        break;
+      }
+    }
   }
+}
 
-  /** Log a message with `DEBUG`/`LOG` level. */
-  log(val: string) {
-    this.config.transport.log(this.moduleName, this.fileName, val);
-  }
+declare class OneImmDispatcher {
+  constructor(private hostCallOps: HostCallOps) {}
 
-  /** Log a message with `INFO` level. */
-  info(val: string) {
-    this.config.transport.info(this.moduleName, this.fileName, val);
+  dispatch(instruction: Instruction, args: OneImmediateArgs) {
+    switch (instruction) {
+      case Instruction.ECALLI:
+        this.hostCallOps.hostCall(args.immediateDecoder);
+        break;
+    }
   }
+}
 
-  /** Log a message with `WARN` level. */
-  warn(val: string) {
-    this.config.transport.warn(this.moduleName, this.fileName, val);
-  }
+declare class OneRegOneExtImmDispatcher {
+  constructor(private loadOps: LoadOps) {}
 
-  /** Log a message with `ERROR` level. */
-  error(val: string) {
-    this.config.transport.error(this.moduleName, this.fileName, val);
+  dispatch(instruction: Instruction, args: OneRegisterOneExtendedWidthImmediateArgs) {
+    switch (instruction) {
+      case Instruction.LOAD_IMM_64:
+        this.loadOps.loadImmediateU64(args.registerIndex, args.immediateDecoder);
+        break;
+    }
   }
 }
 
-type index$9_Level = Level;
-declare const index$9_Level: typeof Level;
-type index$9_Logger = Logger;
-declare const index$9_Logger: typeof Logger;
-declare const index$9_parseLoggerOptions: typeof parseLoggerOptions;
-declare namespace index$9 {
-  export {
-    index$9_Level as Level,
-    index$9_Logger as Logger,
-    index$9_parseLoggerOptions as parseLoggerOptions,
-  };
-}
-
 declare enum ProgramDecoderError {
   InvalidProgramError = 0,
 }
@@ -16237,12 +16127,12 @@ declare enum Status {
 
 type InterpreterOptions = {
   useSbrkGas?: boolean;
-  ignoreInstructionGas?: boolean;
 };
 
+declare const logger = Logger.new(import.meta.filename, "pvm");
+
 declare class Interpreter {
   private readonly useSbrkGas: boolean;
-  private readonly ignoreInstructionGas: boolean;
   private registers = new Registers();
   private code: Uint8Array = new Uint8Array();
   private mask = Mask.empty();
@@ -16270,9 +16160,8 @@ declare class Interpreter {
   private basicBlocks: BasicBlocks;
   private jumpTable = JumpTable.empty();
 
-  constructor({ useSbrkGas = false, ignoreInstructionGas = false }: InterpreterOptions = {}) {
+  constructor({ useSbrkGas = false }: InterpreterOptions = {}) {
     this.useSbrkGas = useSbrkGas;
-    this.ignoreInstructionGas = ignoreInstructionGas;
     this.argsDecoder = new ArgsDecoder();
     this.basicBlocks = new BasicBlocks();
     const mathOps = new MathOps(this.registers);
@@ -16368,7 +16257,7 @@ declare class Interpreter {
     const currentInstruction = this.code[this.pc] ?? Instruction.TRAP;
     const isValidInstruction = Instruction[currentInstruction] !== undefined;
     const gasCost = instructionGasMap[currentInstruction] ?? instructionGasMap[Instruction.TRAP];
-    const underflow = this.ignoreInstructionGas ? false : this.gas.sub(gasCost);
+    const underflow = this.gas.sub(gasCost);
     if (underflow) {
       this.status = Status.OOG;
       return this.status;
@@ -16377,6 +16266,8 @@ declare class Interpreter {
     const argsResult = this.argsDecodingResults[argsType];
     this.argsDecoder.fillArgs(this.pc, argsResult);
 
+    logger.insane(`[PC: ${this.pc}] ${Instruction[currentInstruction]}`);
+
     if (!isValidInstruction) {
       this.instructionResult.status = Result.PANIC;
     } else {
@@ -16437,12 +16328,6 @@ declare class Interpreter {
     }
 
     if (this.instructionResult.status !== null) {
-      // All abnormal terminations should be interpreted as TRAP and we should subtract the gas. In case of FAULT we have to do it manually at the very end.
-      if (this.instructionResult.status === Result.FAULT || this.instructionResult.status === Result.FAULT_ACCESS) {
-        // TODO [ToDr] underflow?
-        this.gas.sub(instructionGasMap[Instruction.TRAP]);
-      }
-
       switch (this.instructionResult.status) {
         case Result.FAULT:
           this.status = Status.FAULT;
@@ -16458,6 +16343,7 @@ declare class Interpreter {
           this.status = Status.HOST;
           break;
       }
+      logger.insane(`[PC: ${this.pc}] Status: ${Result[this.instructionResult.status]}`);
       return this.status;
     }
 
@@ -16529,13 +16415,14 @@ declare const index$8_Registers: typeof Registers;
 type index$8_SbrkIndex = SbrkIndex;
 type index$8_SmallGas = SmallGas;
 declare const index$8_gasCounter: typeof gasCounter;
+declare const index$8_logger: typeof logger;
 declare const index$8_tryAsBigGas: typeof tryAsBigGas;
 declare const index$8_tryAsGas: typeof tryAsGas;
 declare const index$8_tryAsMemoryIndex: typeof tryAsMemoryIndex;
 declare const index$8_tryAsSbrkIndex: typeof tryAsSbrkIndex;
 declare const index$8_tryAsSmallGas: typeof tryAsSmallGas;
 declare namespace index$8 {
-  export { index$8_Interpreter as Interpreter, index$8_Memory as Memory, index$8_MemoryBuilder as MemoryBuilder, index$8_Registers as Registers, index$8_gasCounter as gasCounter, index$8_tryAsBigGas as tryAsBigGas, index$8_tryAsGas as tryAsGas, index$8_tryAsMemoryIndex as tryAsMemoryIndex, index$8_tryAsSbrkIndex as tryAsSbrkIndex, index$8_tryAsSmallGas as tryAsSmallGas };
+  export { index$8_Interpreter as Interpreter, index$8_Memory as Memory, index$8_MemoryBuilder as MemoryBuilder, index$8_Registers as Registers, index$8_gasCounter as gasCounter, index$8_logger as logger, index$8_tryAsBigGas as tryAsBigGas, index$8_tryAsGas as tryAsGas, index$8_tryAsMemoryIndex as tryAsMemoryIndex, index$8_tryAsSbrkIndex as tryAsSbrkIndex, index$8_tryAsSmallGas as tryAsSmallGas };
   export type { index$8_BigGas as BigGas, index$8_Gas as Gas, index$8_GasCounter as GasCounter, index$8_InterpreterOptions as InterpreterOptions, index$8_MemoryIndex as MemoryIndex, index$8_SbrkIndex as SbrkIndex, index$8_SmallGas as SmallGas };
 }
 
@@ -16618,7 +16505,7 @@ interface HostCallHandler {
   readonly gasCost: SmallGas | ((reg: IHostCallRegisters) => Gas);
 
   /** Currently executing service id. */
-  readonly currentServiceId: ServiceId;
+  readonly currentServiceId: U32;
 
   /** Input&Output registers that we should add to tracing log. */
   readonly tracedRegisters: RegisterIndex[];
@@ -16631,14 +16518,21 @@ interface HostCallHandler {
   execute(gas: GasCounter, regs: IHostCallRegisters, memory: IHostCallMemory): Promise<undefined | PvmExecution>;
 }
 
-// TODO [ToDr] Rename to just `HostCalls`
 /** Container for all available host calls. */
 declare class HostCallsManager {
   private readonly hostCalls = new Map<HostCallIndex, HostCallHandler>();
-  private readonly missing = new Missing();
+  private readonly missing;
+
+  constructor({
+    missing,
+    handlers = [],
+  }: {
+    missing: HostCallHandler;
+    handlers?: HostCallHandler[];
+  }) {
+    this.missing = missing;
 
-  constructor(...hostCallHandlers: HostCallHandler[]) {
-    for (const handler of hostCallHandlers) {
+    for (const handler of handlers) {
       check(this.hostCalls.get(handler.index) === undefined, `Overwriting host call handler at index ${handler.index}`);
       this.hostCalls.set(handler.index, handler);
     }
@@ -16666,7 +16560,7 @@ declare class HostCallsManager {
         return `r${idx}=${value} (0x${value.toString(16)})`;
       })
       .join(", ");
-    logger.trace(`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`);
+    logger.insane(`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`);
   }
 }
 
@@ -16677,16 +16571,10 @@ declare class InterpreterInstanceManager {
   private waitingQueue: ResolveFn[] = [];
 
   constructor(noOfPvmInstances: number) {
-    const shouldCountGas =
-      Compatibility.isGreaterOrEqual(GpVersion.V0_6_7) ||
-      Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_5) ||
-      Compatibility.isSuite(TestSuite.W3F_DAVXY, GpVersion.V0_6_6);
-
     for (let i = 0; i < noOfPvmInstances; i++) {
       this.instances.push(
         new Interpreter({
           useSbrkGas: false,
-          ignoreInstructionGas: !shouldCountGas,
         }),
       );
     }
@@ -16793,14 +16681,15 @@ declare class HostCalls {
       const gasCost = typeof hostCall.gasCost === "number" ? hostCall.gasCost : hostCall.gasCost(regs);
       const underflow = gas.sub(gasCost);
 
+      const pcLog = `[PC: ${pvmInstance.getPC()}]`;
       if (underflow) {
-        this.hostCalls.traceHostCall("OOG", index, hostCall, regs, gas.get());
+        this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
         return ReturnValue.fromStatus(pvmInstance.getGasConsumed(), Status.OOG);
       }
-      this.hostCalls.traceHostCall("Invoking", index, hostCall, regs, gasBefore);
+      this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
       const result = await hostCall.execute(gas, regs, memory);
       this.hostCalls.traceHostCall(
-        result === undefined ? "Result" : `Status(${result})`,
+        result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`,
         index,
         hostCall,
         regs,
@@ -16812,8 +16701,18 @@ declare class HostCalls {
         return this.getReturnValue(status, pvmInstance);
       }
 
-      pvmInstance.runProgram();
-      status = pvmInstance.getStatus();
+      if (result === PvmExecution.Panic) {
+        status = Status.PANIC;
+        return this.getReturnValue(status, pvmInstance);
+      }
+
+      if (result === undefined) {
+        pvmInstance.runProgram();
+        status = pvmInstance.getStatus();
+        continue;
+      }
+
+      assertNever(result);
     }
   }
 
@@ -18152,6 +18051,7 @@ declare const index$3_getServiceId: typeof getServiceId;
 declare const index$3_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
 declare const index$3_inspect: typeof inspect;
 declare const index$3_instructionArgumentTypeMap: typeof instructionArgumentTypeMap;
+declare const index$3_isBrowser: typeof isBrowser;
 declare const index$3_isTaggedError: typeof isTaggedError;
 declare const index$3_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
 declare const index$3_measure: typeof measure;
@@ -18164,7 +18064,7 @@ declare const index$3_tryAsMachineId: typeof tryAsMachineId;
 declare const index$3_tryAsProgramCounter: typeof tryAsProgramCounter;
 declare const index$3_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$3 {
-  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$j as block, index$q as bytes, index$3_cast as cast, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_ensure as ensure, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$n as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$p as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$j as block, index$q as bytes, index$3_cast as cast, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_ensure as ensure, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$n as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$p as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
   export type { index$3_Args as Args, index$3_EnumMapping as EnumMapping, index$3_ErrorResult as ErrorResult, index$3_IHostCallMemory as IHostCallMemory, index$3_IHostCallRegisters as IHostCallRegisters, index$3_InsufficientFundsError as InsufficientFundsError, index$3_MachineId as MachineId, index$3_MachineResult as MachineResult, index$3_MachineStatus as MachineStatus, index$3_NoMachineError as NoMachineError, index$3_OK as OK, index$3_OkResult as OkResult, index$3_Opaque as Opaque, index$3_PartialState as PartialState, index$3_PreimageStatus as PreimageStatus, index$3_ProgramCounter as ProgramCounter, index$3_RefineExternalities as RefineExternalities, index$3_SegmentExportError as SegmentExportError, index$3_ServiceStateUpdate as ServiceStateUpdate, index$3_StateSlice as StateSlice, index$3_StringLiteral as StringLiteral, index$3_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$3_TaggedError as TaggedError, index$3_TokenOf as TokenOf, index$3_Uninstantiable as Uninstantiable, index$3_UnprivilegedError as UnprivilegedError, index$3_WithOpaque as WithOpaque };
 }
 
@@ -18202,41 +18102,7 @@ declare namespace index$2 {
   };
 }
 
-declare class JsonServiceInfoPre067 {
-  static fromJson = json.object<JsonServiceInfoPre067, ServiceAccountInfo>(
-    {
-      code_hash: fromJson.bytes32(),
-      balance: json.fromNumber((x) => tryAsU64(x)),
-      min_item_gas: json.fromNumber((x) => tryAsServiceGas(x)),
-      min_memo_gas: json.fromNumber((x) => tryAsServiceGas(x)),
-      bytes: json.fromNumber((x) => tryAsU64(x)),
-      items: "number",
-    },
-    ({ code_hash, balance, min_item_gas, min_memo_gas, bytes, items }) => {
-      return ServiceAccountInfo.create({
-        codeHash: code_hash,
-        balance,
-        accumulateMinGas: min_item_gas,
-        onTransferMinGas: min_memo_gas,
-        storageUtilisationBytes: bytes,
-        storageUtilisationCount: items,
-        gratisStorage: tryAsU64(0),
-        created: tryAsTimeSlot(0),
-        lastAccumulation: tryAsTimeSlot(0),
-        parentService: tryAsServiceId(0),
-      });
-    },
-  );
-
-  code_hash!: CodeHash;
-  balance!: U64;
-  min_item_gas!: ServiceGas;
-  min_memo_gas!: ServiceGas;
-  bytes!: U64;
-  items!: U32;
-}
-
-declare class JsonServiceInfo extends JsonServiceInfoPre067 {
+declare class JsonServiceInfo {
   static fromJson = json.object<JsonServiceInfo, ServiceAccountInfo>(
     {
       code_hash: fromJson.bytes32(),
@@ -18277,6 +18143,12 @@ declare class JsonServiceInfo extends JsonServiceInfoPre067 {
     },
   );
 
+  code_hash!: CodeHash;
+  balance!: U64;
+  min_item_gas!: ServiceGas;
+  min_memo_gas!: ServiceGas;
+  bytes!: U64;
+  items!: U32;
   creation_slot!: TimeSlot;
   deposit_offset!: U64;
   last_accumulation_slot!: TimeSlot;
@@ -18330,9 +18202,7 @@ declare class JsonService {
     {
       id: "number",
       data: {
-        service: Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-          ? JsonServiceInfo.fromJson
-          : JsonServiceInfoPre067.fromJson,
+        service: JsonServiceInfo.fromJson,
         preimages: json.optional(json.array(JsonPreimageItem.fromJson)),
         storage: json.optional(json.array(JsonStorageItem.fromJson)),
         lookup_meta: json.optional(json.array(lookupMetaFromJson)),
@@ -18470,7 +18340,7 @@ type JsonRecentBlockState = {
   reported: WorkPackageInfo[];
 };
 
-declare const recentBlocksFromJson = json.object<JsonRecentBlocks, RecentBlocksHistory>(
+declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, RecentBlocksHistory>(
   {
     history: json.array(recentBlockStateFromJson),
     mmr: {
@@ -18494,49 +18364,6 @@ type JsonRecentBlocks = {
   };
 };
 
-declare const legacyRecentBlockStateFromJson = json.object<JsonRecentBlockStateLegacy, LegacyBlockState>(
-  {
-    header_hash: fromJson.bytes32(),
-    mmr: {
-      peaks: json.array(json.nullable(fromJson.bytes32())),
-    },
-    state_root: fromJson.bytes32(),
-    reported: json.array(reportedWorkPackageFromJson),
-  },
-  ({ header_hash, mmr, state_root, reported }) => {
-    return {
-      headerHash: header_hash,
-      mmr,
-      postStateRoot: state_root,
-      reported: HashDictionary.fromEntries(reported.map((x) => [x.workPackageHash, x])),
-    };
-  },
-);
-
-type JsonRecentBlockStateLegacy = {
-  header_hash: HeaderHash;
-  mmr: {
-    peaks: Array<KeccakHash | null>;
-  };
-  state_root: StateRootHash;
-  reported: WorkPackageInfo[];
-};
-
-declare const legacyRecentBlocksFromJson = json.object<LegacyBlocksState, RecentBlocksHistory>(
-  json.array(legacyRecentBlockStateFromJson),
-  (blocks) => {
-    return RecentBlocksHistory.legacyCreate(
-      LegacyRecentBlocks.create({
-        blocks,
-      }),
-    );
-  },
-);
-
-declare const recentBlocksHistoryFromJson = Compatibility.isGreaterOrEqual(GpVersion.V0_6_7)
-  ? recentBlocksFromJson
-  : legacyRecentBlocksFromJson;
-
 declare const ticketFromJson: FromJson<Ticket> = json.object<Ticket>(
   {
     id: fromJson.bytes32(),
@@ -18878,138 +18705,6 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
     },
   );
 
-type JsonStateDumpPre067 = {
-  alpha: AuthorizerHash[][];
-  varphi: AuthorizerHash[][];
-  beta: State["recentBlocks"] | null;
-  gamma: {
-    gamma_k: State["nextValidatorData"];
-    gamma_z: State["epochRoot"];
-    gamma_s: TicketsOrKeys;
-    gamma_a: State["ticketsAccumulator"];
-  };
-  psi: State["disputesRecords"];
-  eta: State["entropy"];
-  iota: State["designatedValidatorData"];
-  kappa: State["currentValidatorData"];
-  lambda: State["previousValidatorData"];
-  rho: State["availabilityAssignment"];
-  tau: State["timeslot"];
-  chi: {
-    chi_m: PrivilegedServices["manager"];
-    chi_a: ServiceId; // NOTE: [MaSo] pre067
-    chi_v: PrivilegedServices["validatorsManager"];
-    chi_g: PrivilegedServices["autoAccumulateServices"] | null;
-  };
-  pi: JsonStatisticsData;
-  theta: State["accumulationQueue"];
-  xi: PerEpochBlock<WorkPackageHash[]>;
-  accounts: InMemoryService[];
-};
-
-declare const fullStateDumpFromJsonPre067 = (spec: ChainSpec) =>
-  json.object<JsonStateDumpPre067, InMemoryState>(
-    {
-      alpha: json.array(json.array(fromJson.bytes32<AuthorizerHash>())),
-      varphi: json.array(json.array(fromJson.bytes32<AuthorizerHash>())),
-      beta: json.nullable(recentBlocksHistoryFromJson),
-      gamma: {
-        gamma_k: json.array(validatorDataFromJson),
-        gamma_a: json.array(ticketFromJson),
-        gamma_s: TicketsOrKeys.fromJson,
-        gamma_z: json.fromString((v) => Bytes.parseBytes(v, BANDERSNATCH_RING_ROOT_BYTES).asOpaque()),
-      },
-      psi: disputesRecordsFromJson,
-      eta: json.array(fromJson.bytes32<EntropyHash>()),
-      iota: json.array(validatorDataFromJson),
-      kappa: json.array(validatorDataFromJson),
-      lambda: json.array(validatorDataFromJson),
-      rho: json.array(json.nullable(availabilityAssignmentFromJson)),
-      tau: "number",
-      chi: {
-        chi_m: "number",
-        chi_a: "number",
-        chi_v: "number",
-        chi_g: json.nullable(
-          json.array({
-            service: "number",
-            gasLimit: json.fromNumber((v) => tryAsServiceGas(v)),
-          }),
-        ),
-      },
-      pi: JsonStatisticsData.fromJson,
-      theta: json.array(json.array(notYetAccumulatedFromJson)),
-      xi: json.array(json.array(fromJson.bytes32())),
-      accounts: json.array(JsonService.fromJson),
-    },
-    ({
-      alpha,
-      varphi,
-      beta,
-      gamma,
-      psi,
-      eta,
-      iota,
-      kappa,
-      lambda,
-      rho,
-      tau,
-      chi,
-      pi,
-      theta,
-      xi,
-      accounts,
-    }): InMemoryState => {
-      return InMemoryState.create({
-        authPools: tryAsPerCore(
-          alpha.map((perCore) => {
-            if (perCore.length > MAX_AUTH_POOL_SIZE) {
-              throw new Error(`AuthPools: expected less than ${MAX_AUTH_POOL_SIZE}, got ${perCore.length}`);
-            }
-            return asKnownSize(perCore);
-          }),
-          spec,
-        ),
-        authQueues: tryAsPerCore(
-          varphi.map((perCore) => {
-            if (perCore.length !== AUTHORIZATION_QUEUE_SIZE) {
-              throw new Error(`AuthQueues: expected ${AUTHORIZATION_QUEUE_SIZE}, got: ${perCore.length}`);
-            }
-            return asKnownSize(perCore);
-          }),
-          spec,
-        ),
-        recentBlocks: beta ?? RecentBlocksHistory.empty(),
-        nextValidatorData: gamma.gamma_k,
-        epochRoot: gamma.gamma_z,
-        sealingKeySeries: TicketsOrKeys.toSafroleSealingKeys(gamma.gamma_s, spec),
-        ticketsAccumulator: gamma.gamma_a,
-        disputesRecords: psi,
-        entropy: eta,
-        designatedValidatorData: iota,
-        currentValidatorData: kappa,
-        previousValidatorData: lambda,
-        availabilityAssignment: rho,
-        timeslot: tau,
-        privilegedServices: PrivilegedServices.create({
-          manager: chi.chi_m,
-          authManager: tryAsPerCore(new Array(spec.coresCount).fill(chi.chi_a), spec),
-          validatorsManager: chi.chi_v,
-          autoAccumulateServices: chi.chi_g ?? [],
-        }),
-        statistics: JsonStatisticsData.toStatisticsData(spec, pi),
-        accumulationQueue: theta,
-        recentlyAccumulated: tryAsPerEpochBlock(
-          xi.map((x) => HashSet.from(x)),
-          spec,
-        ),
-        services: new Map(accounts.map((x) => [x.serviceId, x])),
-        // NOTE Field not present in pre067, added here for compatibility reasons
-        accumulationOutputLog: [],
-      });
-    },
-  );
-
 type index$1_JsonAvailabilityAssignment = JsonAvailabilityAssignment;
 type index$1_JsonCoreStatistics = JsonCoreStatistics;
 declare const index$1_JsonCoreStatistics: typeof JsonCoreStatistics;
@@ -19019,19 +18714,15 @@ type index$1_JsonLookupMeta = JsonLookupMeta;
 type index$1_JsonPreimageItem = JsonPreimageItem;
 declare const index$1_JsonPreimageItem: typeof JsonPreimageItem;
 type index$1_JsonRecentBlockState = JsonRecentBlockState;
-type index$1_JsonRecentBlockStateLegacy = JsonRecentBlockStateLegacy;
 type index$1_JsonRecentBlocks = JsonRecentBlocks;
 type index$1_JsonReportedWorkPackageInfo = JsonReportedWorkPackageInfo;
 type index$1_JsonService = JsonService;
 declare const index$1_JsonService: typeof JsonService;
 type index$1_JsonServiceInfo = JsonServiceInfo;
 declare const index$1_JsonServiceInfo: typeof JsonServiceInfo;
-type index$1_JsonServiceInfoPre067 = JsonServiceInfoPre067;
-declare const index$1_JsonServiceInfoPre067: typeof JsonServiceInfoPre067;
 type index$1_JsonServiceStatistics = JsonServiceStatistics;
 declare const index$1_JsonServiceStatistics: typeof JsonServiceStatistics;
 type index$1_JsonStateDump = JsonStateDump;
-type index$1_JsonStateDumpPre067 = JsonStateDumpPre067;
 type index$1_JsonStatisticsData = JsonStatisticsData;
 declare const index$1_JsonStatisticsData: typeof JsonStatisticsData;
 type index$1_JsonStorageItem = JsonStorageItem;
@@ -19044,21 +18735,17 @@ declare const index$1_TicketsOrKeys: typeof TicketsOrKeys;
 declare const index$1_availabilityAssignmentFromJson: typeof availabilityAssignmentFromJson;
 declare const index$1_disputesRecordsFromJson: typeof disputesRecordsFromJson;
 declare const index$1_fullStateDumpFromJson: typeof fullStateDumpFromJson;
-declare const index$1_fullStateDumpFromJsonPre067: typeof fullStateDumpFromJsonPre067;
-declare const index$1_legacyRecentBlockStateFromJson: typeof legacyRecentBlockStateFromJson;
-declare const index$1_legacyRecentBlocksFromJson: typeof legacyRecentBlocksFromJson;
 declare const index$1_lookupMetaFromJson: typeof lookupMetaFromJson;
 declare const index$1_notYetAccumulatedFromJson: typeof notYetAccumulatedFromJson;
 declare const index$1_recentBlockStateFromJson: typeof recentBlockStateFromJson;
-declare const index$1_recentBlocksFromJson: typeof recentBlocksFromJson;
 declare const index$1_recentBlocksHistoryFromJson: typeof recentBlocksHistoryFromJson;
 declare const index$1_reportedWorkPackageFromJson: typeof reportedWorkPackageFromJson;
 declare const index$1_serviceStatisticsEntryFromJson: typeof serviceStatisticsEntryFromJson;
 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_JsonServiceInfoPre067 as JsonServiceInfoPre067, 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_fullStateDumpFromJsonPre067 as fullStateDumpFromJsonPre067, index$1_legacyRecentBlockStateFromJson as legacyRecentBlockStateFromJson, index$1_legacyRecentBlocksFromJson as legacyRecentBlocksFromJson, index$1_lookupMetaFromJson as lookupMetaFromJson, index$1_notYetAccumulatedFromJson as notYetAccumulatedFromJson, index$1_recentBlockStateFromJson as recentBlockStateFromJson, index$1_recentBlocksFromJson as recentBlocksFromJson, 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_JsonRecentBlockStateLegacy as JsonRecentBlockStateLegacy, index$1_JsonRecentBlocks as JsonRecentBlocks, index$1_JsonReportedWorkPackageInfo as JsonReportedWorkPackageInfo, index$1_JsonStateDump as JsonStateDump, index$1_JsonStateDumpPre067 as JsonStateDumpPre067, 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_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 };
 }
 
 /** Helper function to create most used hashes in the block */
@@ -19257,7 +18944,7 @@ declare class WorkPackageExecutor {
 
 declare class PvmExecutor {
   private readonly pvm: HostCalls;
-  private hostCalls = new HostCalls();
+  private hostCalls = new HostCallsManager({ missing: new Missing() });
   private pvmInstanceManager = new PvmInstanceManager(4);
 
   constructor(private serviceCode: BytesBlob) {