@typeberry/lib 0.0.1-886997c → 0.0.1-8d96ad4

package/configs/index.d.ts

@@ -0,0 +1,74 @@
+export declare const configs: {
+    default: {
+        $schema: string;
+        version: number;
+        flavor: string;
+        authorship: {
+            omit_seal_verification: boolean;
+        };
+        chain_spec: {
+            id: string;
+            bootnodes: string[];
+            genesis_header: string;
+            genesis_state: {
+                "01000000000000000000000000000000000000000000000000000000000000": string;
+                "02000000000000000000000000000000000000000000000000000000000000": string;
+                "03000000000000000000000000000000000000000000000000000000000000": string;
+                "04000000000000000000000000000000000000000000000000000000000000": string;
+                "05000000000000000000000000000000000000000000000000000000000000": string;
+                "06000000000000000000000000000000000000000000000000000000000000": string;
+                "07000000000000000000000000000000000000000000000000000000000000": string;
+                "08000000000000000000000000000000000000000000000000000000000000": string;
+                "09000000000000000000000000000000000000000000000000000000000000": string;
+                "0a000000000000000000000000000000000000000000000000000000000000": string;
+                "0b000000000000000000000000000000000000000000000000000000000000": string;
+                "0c000000000000000000000000000000000000000000000000000000000000": string;
+                "0d000000000000000000000000000000000000000000000000000000000000": string;
+                "0e000000000000000000000000000000000000000000000000000000000000": string;
+                "0f000000000000000000000000000000000000000000000000000000000000": string;
+                ff000000000000000000000000000000000000000000000000000000000000: string;
+                "00fe00ff00ff00ff6326432b5b3213dfd1609495e13c6b276cb474d6796453": string;
+                "00fe00ff00ff00fff8485e3a88e86182e63280720d5ec9892578f0e577fb1b": string;
+                "0023000000000000478648cd19b4f812f897a26976ecf312eac28508b4368d": string;
+                "004b000400000000f324d112c31c3778a072940b55dd35f3a4b77e72d2d2db": string;
+            };
+        };
+        database_base_path: string;
+    };
+    dev: {
+        $schema: string;
+        version: number;
+        flavor: string;
+        authorship: {
+            omit_seal_verification: boolean;
+        };
+        chain_spec: {
+            id: string;
+            bootnodes: string[];
+            genesis_header: string;
+            genesis_state: {
+                "01000000000000000000000000000000000000000000000000000000000000": string;
+                "02000000000000000000000000000000000000000000000000000000000000": string;
+                "03000000000000000000000000000000000000000000000000000000000000": string;
+                "04000000000000000000000000000000000000000000000000000000000000": string;
+                "05000000000000000000000000000000000000000000000000000000000000": string;
+                "06000000000000000000000000000000000000000000000000000000000000": string;
+                "07000000000000000000000000000000000000000000000000000000000000": string;
+                "08000000000000000000000000000000000000000000000000000000000000": string;
+                "09000000000000000000000000000000000000000000000000000000000000": string;
+                "0a000000000000000000000000000000000000000000000000000000000000": string;
+                "0b000000000000000000000000000000000000000000000000000000000000": string;
+                "0c000000000000000000000000000000000000000000000000000000000000": string;
+                "0d000000000000000000000000000000000000000000000000000000000000": string;
+                "0e000000000000000000000000000000000000000000000000000000000000": string;
+                "0f000000000000000000000000000000000000000000000000000000000000": string;
+                ff000000000000000000000000000000000000000000000000000000000000: string;
+                "00fe00ff00ff00ff6326432b5b3213dfd1609495e13c6b276cb474d6796453": string;
+                "00fe00ff00ff00fff8485e3a88e86182e63280720d5ec9892578f0e577fb1b": string;
+                "0023000000000000478648cd19b4f812f897a26976ecf312eac28508b4368d": string;
+                "004b000400000000f324d112c31c3778a072940b55dd35f3a4b77e72d2d2db": string;
+            };
+        };
+        database_base_path: string;
+    };
+};

package/index.d.ts

@@ -160,6 +160,10 @@ declare class Compatibility {
   }
 }
 
+declare function isBrowser() {
+  return typeof process === "undefined" || typeof process.abort === "undefined";
+}
+
 /**
  * A function to perform runtime assertions.
  *
@@ -278,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 {
@@ -778,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;
@@ -788,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 };
 }
 
@@ -4456,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;
@@ -4548,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);
 }
 
@@ -4570,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;
@@ -4590,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;
@@ -4700,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");
 
@@ -4826,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 };
 }
 
@@ -7820,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,
 };
 
@@ -7875,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 {
@@ -8743,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(
@@ -10361,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(
@@ -10374,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(
@@ -10385,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"]> = {
@@ -10394,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,
@@ -10407,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,
@@ -10477,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(
@@ -12245,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++) {
@@ -12288,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
 
@@ -12527,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;
@@ -12540,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;
@@ -12548,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 };
 }
 
@@ -13839,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 = {
@@ -16690,8 +16711,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);
     }
   }
 
@@ -18030,6 +18061,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;
@@ -18042,7 +18074,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 };
 }