@typeberry/lib 0.0.1-1c07527 → 0.0.1-53acce8

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 {
@@ -786,6 +781,7 @@ 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;
@@ -796,7 +792,7 @@ 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_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 +2328,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 +2755,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 +2775,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 +3395,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 +3410,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 +4460,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 +4630,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 +4652,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 +4672,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 +4729,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 +4855,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 +5574,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 +5652,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 +5987,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 +6151,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 +6185,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 +6263,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 +6288,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 +6297,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 +7849,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 +7904,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 {
@@ -8432,60 +8454,6 @@ declare namespace index$f {
 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();
-  }
-}
-
 /** Array of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
 type BlocksState = KnownSizeArray<BlockState, `0..${typeof MAX_RECENT_HISTORY}`>;
 
@@ -8549,87 +8517,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 +8575,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 +8584,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 +8772,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(
@@ -9211,9 +9120,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 +10162,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 +10232,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 +10377,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 +10390,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 +10401,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 +10409,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 +10422,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 +10492,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(
@@ -12359,8 +12260,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 +12303,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
 
@@ -12641,6 +12542,10 @@ declare function chunksToShards(
   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;
@@ -12654,6 +12559,7 @@ 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;
@@ -12662,7 +12568,7 @@ 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 { 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 };
 }
 
@@ -13953,13 +13859,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 = {
@@ -16237,12 +16144,10 @@ declare enum Status {
 
 type InterpreterOptions = {
   useSbrkGas?: boolean;
-  ignoreInstructionGas?: boolean;
 };
 
 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 +16175,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 +16272,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;
@@ -16437,12 +16341,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;
@@ -16618,7 +16516,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 +16529,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);
     }
@@ -16677,16 +16582,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,
         }),
       );
     }
@@ -16800,7 +16699,7 @@ declare class HostCalls {
       this.hostCalls.traceHostCall("Invoking", index, hostCall, regs, gasBefore);
       const result = await hostCall.execute(gas, regs, memory);
       this.hostCalls.traceHostCall(
-        result === undefined ? "Result" : `Status(${result})`,
+        result === undefined ? "Result" : `Status(${PvmExecution[result]})`,
         index,
         hostCall,
         regs,
@@ -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 };
 }
 
@@ -18470,7 +18370,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 +18394,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(),
@@ -19019,7 +18876,6 @@ 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;
@@ -19045,20 +18901,17 @@ declare const index$1_availabilityAssignmentFromJson: typeof availabilityAssignm
 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_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_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_JsonStateDumpPre067 as JsonStateDumpPre067, index$1_ServiceStatisticsEntry as ServiceStatisticsEntry };
 }
 
 /** Helper function to create most used hashes in the block */
@@ -19257,7 +19110,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) {