@typeberry/jam 0.1.0-b2d0b72 → 0.1.0-eb00e84

package/index.js

@@ -28332,17 +28332,29 @@ function isBrowser() {
  * We avoid using `node:assert` to keep compatibility with a browser environment.
  * Note the checks should not have any side effects, since we might decide
  * to remove all of them in a post-processing step.
- *
- * NOTE the function is intended to be used as tagged template string for the performance
- * reasons.
  */
-function debug_check(strings, condition, ...data) {
+function debug_check(condition, message) {
     if (!condition) {
-        // add an empty value so that `data.length === strings.length`
-        data.unshift("");
-        const message = strings.map((v, index) => `${v}${data[index] ?? ""}`);
-        throw new Error(`Assertion failure:${message.join("")}`);
+        throw new Error(`Assertion failure: ${message ?? ""}`);
+    }
+}
+function cast(_a, condition) {
+    return condition;
+}
+/**
+ * Yet another function to perform runtime assertions.
+ * This function returns a new type to mark in the code that this value was checked and you don't have to do it again.
+ *
+ * In the post-processing step all usages of this functions should be replaced with simple casting. An example:
+ * const x = checkAndType<number, CheckedNumber>(y);
+ * should be replaced with:
+ * const x = y as CheckedNumber;
+ */
+function ensure(a, condition, message) {
+    if (cast(a, condition)) {
+        return a;
     }
+    throw new Error(`Assertion failure: ${message ?? ""}`);
 }
 /**
  * The function can be used to make sure that a particular type is `never`
@@ -28512,7 +28524,7 @@ function resultToString(res) {
 const result_Result = {
     /** Create new [`Result`] with `Ok` status. */
     ok: (ok) => {
-        debug_check `${ok !== undefined} 'ok' type cannot be undefined.`;
+        debug_check(ok !== undefined, "`Ok` type cannot be undefined.");
         return {
             isOk: true,
             isError: false,
@@ -28521,7 +28533,7 @@ const result_Result = {
     },
     /** Create new [`Result`] with `Error` status. */
     error: (error, details = "") => {
-        debug_check `${error !== undefined} 'Error' type cannot be undefined.`;
+        debug_check(error !== undefined, "`Error` type cannot be undefined.");
         return {
             isOk: false,
             isError: true,
@@ -28805,10 +28817,7 @@ class BitVec {
     constructor(data, bitLength) {
         this.data = data;
         this.bitLength = bitLength;
-        debug_check `
-      ${data.length * 8 >= bitLength}
-      Not enough bytes in the data array. Need ${data.length * 8} has ${bitLength}.
-    `;
+        debug_check(data.length * 8 >= bitLength, `Not enough bytes in the data array. Need ${data.length * 8} has ${bitLength}.`);
         this.byteLength = Math.ceil(bitLength / 8);
     }
     /** Return a raw in-memory representation of this [`BitVec`]. */
@@ -28817,10 +28826,7 @@ class BitVec {
     }
     /** Perform OR operation on all bits in place. */
     sumWith(other) {
-        debug_check `
-      ${other.bitLength === this.bitLength}
-      Invalid bit length for sumWith: ${other.bitLength} vs ${this.bitLength}
-    `;
+        debug_check(other.bitLength === this.bitLength, `Invalid bit length for sumWith: ${other.bitLength} vs ${this.bitLength}`);
         const otherRaw = other.raw;
         for (let i = 0; i < this.byteLength; i++) {
             this.data[i] |= otherRaw[i];
@@ -28830,7 +28836,7 @@ class BitVec {
      * Set the bit at index `idx` to value `val`.
      */
     setBit(idx, val) {
-        debug_check `${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
+        debug_check(idx < this.bitLength, `Index out of bounds. Need ${idx} has ${this.bitLength}.`);
         const byteIndex = Math.floor(idx / 8);
         const bitIndexInByte = idx % 8;
         const mask = 1 << bitIndexInByte;
@@ -28845,7 +28851,7 @@ class BitVec {
      * Return `true` if the bit at index `idx` is set.
      */
     isSet(idx) {
-        debug_check `${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
+        debug_check(idx < this.bitLength, `Index out of bounds. Need ${idx} has ${this.bitLength}.`);
         const byteIndex = Math.floor(idx / 8);
         const bitIndexInByte = idx % 8;
         const mask = 1 << bitIndexInByte;
@@ -29012,7 +29018,7 @@ class bytes_BytesBlob {
     }
     /** Create a new [`BytesBlob`] from an array of bytes. */
     static blobFromNumbers(v) {
-        debug_check `${v.find((x) => (x & 0xff) !== x) === undefined} BytesBlob.blobFromNumbers used with non-byte number array.`;
+        debug_check(v.find((x) => (x & 0xff) !== x) === undefined, "BytesBlob.blobFromNumbers used with non-byte number array.");
         const arr = new Uint8Array(v);
         return new bytes_BytesBlob(arr);
     }
@@ -29056,7 +29062,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     length;
     constructor(raw, len) {
         super(raw);
-        debug_check `${raw.byteLength === len} Given buffer has incorrect size ${raw.byteLength} vs expected ${len}`;
+        debug_check(raw.byteLength === len, `Given buffer has incorrect size ${raw.byteLength} vs expected ${len}`);
         this.length = len;
     }
     /** Create new [`Bytes<X>`] given a backing buffer and it's length. */
@@ -29065,7 +29071,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     }
     /** Create new [`Bytes<X>`] given an array of bytes and it's length. */
     static fromNumbers(v, len) {
-        debug_check `${v.find((x) => (x & 0xff) !== x) === undefined} Bytes.fromNumbers used with non-byte number array.`;
+        debug_check(v.find((x) => (x & 0xff) !== x) === undefined, "Bytes.fromNumbers used with non-byte number array.");
         const x = new Uint8Array(v);
         return new bytes_Bytes(x, len);
     }
@@ -29076,7 +29082,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     // TODO [ToDr] `fill` should have the argments swapped to align with the rest.
     /** Create a [`Bytes<X>`] with all bytes filled with given input number. */
     static fill(len, input) {
-        debug_check `${(input & 0xff) === input} Input has to be a byte.`;
+        debug_check((input & 0xff) === input, "Input has to be a byte.");
         const bytes = bytes_Bytes.zero(len);
         bytes.raw.fill(input, 0, len);
         return bytes;
@@ -29099,7 +29105,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     }
     /** Compare the sequence to another one. */
     isEqualTo(other) {
-        debug_check `${this.length === other.length} Comparing incorrectly typed bytes!`;
+        debug_check(this.length === other.length, "Comparing incorrectly typed bytes!");
         return u8ArraySameLengthEqual(this.raw, other.raw);
     }
     /** Converts current type into some opaque extension. */
@@ -29108,7 +29114,7 @@ class bytes_Bytes extends bytes_BytesBlob {
     }
 }
 function byteFromString(s) {
-    debug_check `${s.length === 2} Two-character string expected`;
+    debug_check(s.length === 2, "Two-character string expected");
     const a = numberFromCharCode(s.charCodeAt(0));
     const b = numberFromCharCode(s.charCodeAt(1));
     return (a << 4) | b;
@@ -29162,53 +29168,42 @@ const bytesBlobComparator = (a, b) => a.compare(b);
 
 ;// CONCATENATED MODULE: ./packages/core/numbers/index.ts
 
-const asTypedNumber = (v) => v;
+const asWithBytesRepresentation = (v) => v;
 const MAX_VALUE_U8 = 0xff;
 const MAX_VALUE_U16 = 0xffff;
 const MAX_VALUE_U32 = 0xffff_ffff;
 const MAX_VALUE_U64 = 0xffffffffffffffffn;
 /** Attempt to cast an input number into U8. */
-const tryAsU8 = (v) => {
-    debug_check `${isU8(v)} input must have one-byte representation, got ${v}`;
-    return asTypedNumber(v);
-};
+const tryAsU8 = (v) => ensure(v, isU8(v), `input must have one-byte representation, got ${v}`);
 /** Check if given number is a valid U8 number. */
 const isU8 = (v) => (v & MAX_VALUE_U8) === v;
 /** Attempt to cast an input number into U16. */
-const numbers_tryAsU16 = (v) => {
-    debug_check `${isU16(v)} input must have two-byte representation, got ${v}`;
-    return asTypedNumber(v);
-};
+const numbers_tryAsU16 = (v) => ensure(v, isU16(v), `input must have two-byte representation, got ${v}`);
 /** Check if given number is a valid U16 number. */
 const isU16 = (v) => (v & MAX_VALUE_U16) === v;
 /** Attempt to cast an input number into U32. */
-const numbers_tryAsU32 = (v) => {
-    debug_check `${isU32(v)} input must have four-byte representation, got ${v}`;
-    return asTypedNumber(v);
-};
+const numbers_tryAsU32 = (v) => ensure(v, isU32(v), `input must have four-byte representation, got ${v}`);
 /** Check if given number is a valid U32 number. */
 const isU32 = (v) => (v & MAX_VALUE_U32) >>> 0 === v;
 /** Attempt to cast an input number into U64. */
 const numbers_tryAsU64 = (x) => {
     const v = BigInt(x);
-    debug_check `${isU64(v)} input must have eight-byte representation, got ${x}`;
-    return asTypedNumber(v);
+    return ensure(v, isU64(v), `input must have eight-byte representation, got ${x}`);
 };
 /** Check if given number is a valid U64 number. */
 const isU64 = (v) => (v & MAX_VALUE_U64) === v;
 /** Collate two U32 parts into one U64. */
 const u64FromParts = ({ lower, upper }) => {
     const val = (BigInt(upper) << 32n) + BigInt(lower);
-    return asTypedNumber(val);
+    return asWithBytesRepresentation(val);
 };
 /** Split U64 into lower & upper parts. */
 const u64IntoParts = (v) => {
-    // Number(...) safe: both parts are <= 0xffffffff
-    const lower = Number(v & (2n ** 32n - 1n));
-    const upper = Number(v >> 32n);
+    const lower = v & (2n ** 32n - 1n);
+    const upper = v >> 32n;
     return {
-        lower: asTypedNumber(lower),
-        upper: asTypedNumber(upper),
+        lower: asWithBytesRepresentation(Number(lower)),
+        upper: asWithBytesRepresentation(Number(upper)),
     };
 };
 /**
@@ -29248,8 +29243,8 @@ function numbers_u32AsLeBytes(value) {
  * Interpret 4-byte `Uint8Array` as U32 written as little endian.
  */
 function leBytesAsU32(uint8Array) {
-    debug_check `${uint8Array.length === 4} Input must be a Uint8Array of length 4`;
-    return asTypedNumber(uint8Array[0] | (uint8Array[1] << 8) | (uint8Array[2] << 16) | (uint8Array[3] << 24));
+    debug_check(uint8Array.length === 4, "Input must be a Uint8Array of length 4");
+    return asWithBytesRepresentation(uint8Array[0] | (uint8Array[1] << 8) | (uint8Array[2] << 16) | (uint8Array[3] << 24));
 }
 /** Get the smallest value between U64 a and values given as input parameters. */
 const minU64 = (a, ...values) => values.reduce((min, value) => (value > min ? min : value), a);
@@ -29540,7 +29535,7 @@ class decoder_Decoder {
             this.skip(newOffset - this.offset);
         }
         else {
-            debug_check `${newOffset >= 0} The offset has to be positive`;
+            debug_check(newOffset >= 0, "The offset has to be positive");
             this.offset = newOffset;
         }
     }
@@ -29568,7 +29563,7 @@ class decoder_Decoder {
         return num;
     }
     ensureHasBytes(bytes) {
-        debug_check `${bytes >= 0} Negative number of bytes given.`;
+        debug_check(bytes >= 0, "Negative number of bytes given.");
         if (this.offset + bytes > this.source.length) {
             throw new Error(`Attempting to decode more data than there is left. Need ${bytes}, left: ${this.source.length - this.offset}.`);
         }
@@ -29576,7 +29571,7 @@ class decoder_Decoder {
 }
 const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];
 function decodeVariableLengthExtraBytes(firstByte) {
-    debug_check `${firstByte >= 0 && firstByte < 256} Incorrect byte value: ${firstByte}`;
+    debug_check(firstByte >= 0 && firstByte < 256, `Incorrect byte value: ${firstByte}`);
     for (let i = 0; i < MASKS.length; i++) {
         if (firstByte >= MASKS[i]) {
             return 8 - i;
@@ -29731,7 +29726,7 @@ class descriptor_Descriptor {
 
 
 function tryAsExactBytes(a) {
-    debug_check `${a.isExact} The value is not exact size estimation!`;
+    debug_check(a.isExact, "The value is not exact size estimation!");
     return a.bytes;
 }
 function addSizeHints(a, b) {
@@ -29838,8 +29833,8 @@ class encoder_Encoder {
         // we still allow positive numbers from `[maxNum / 2, maxNum)`.
         // So it does not matter if the argument is a negative value,
         // OR if someone just gave us two-complement already.
-        debug_check `${num < maxNum} Only for numbers up to 2**64 - 1`;
-        debug_check `${-num <= maxNum / 2n} Only for numbers down to -2**63`;
+        debug_check(num < maxNum, "Only for numbers up to 2**64 - 1");
+        debug_check(-num <= maxNum / 2n, "Only for numbers down to -2**63");
         this.ensureBigEnough(8);
         this.dataView.setBigInt64(this.offset, num, true);
         this.offset += 8;
@@ -29903,8 +29898,8 @@ class encoder_Encoder {
         // we still allow positive numbers from `[maxNum / 2, maxNum)`.
         // So it does not matter if the argument is a negative value,
         // OR if someone just gave us two-complement already.
-        debug_check `${num < maxNum} Only for numbers up to 2**${BITS * bytesToEncode} - 1`;
-        debug_check `${-num <= maxNum / 2} Only for numbers down to -2**${BITS * bytesToEncode - 1}`;
+        debug_check(num < maxNum, `Only for numbers up to 2**${BITS * bytesToEncode} - 1`);
+        debug_check(-num <= maxNum / 2, `Only for numbers down to -2**${BITS * bytesToEncode - 1}`);
         this.ensureBigEnough(bytesToEncode);
     }
     /**
@@ -29915,8 +29910,8 @@ class encoder_Encoder {
      * https://graypaper.fluffylabs.dev/#/579bd12/365202365202
      */
     varU32(num) {
-        debug_check `${num >= 0} Only for natural numbers.`;
-        debug_check `${num < 2 ** 32} Only for numbers up to 2**32`;
+        debug_check(num >= 0, "Only for natural numbers.");
+        debug_check(num < 2 ** 32, "Only for numbers up to 2**32");
         this.varU64(BigInt(num));
     }
     /**
@@ -30067,7 +30062,7 @@ class encoder_Encoder {
      * https://graypaper.fluffylabs.dev/#/579bd12/374400374400
      */
     sequenceVarLen(encode, elements) {
-        debug_check `${elements.length <= 2 ** 32} Wow, that's a nice long sequence you've got here.`;
+        debug_check(elements.length <= 2 ** 32, "Wow, that's a nice long sequence you've got here.");
         this.varU32(numbers_tryAsU32(elements.length));
         this.sequenceFixLen(encode, elements);
     }
@@ -30088,7 +30083,7 @@ class encoder_Encoder {
      * anyway, so if we really should throw we will.
      */
     ensureBigEnough(length, options = { silent: false }) {
-        debug_check `${length >= 0} Negative length given`;
+        debug_check(length >= 0, "Negative length given");
         const newLength = this.offset + length;
         if (newLength > MAX_LENGTH) {
             if (options.silent) {
@@ -30224,12 +30219,10 @@ class ObjectView {
     decodeUpTo(field) {
         const index = this.descriptorsKeys.indexOf(field);
         const lastField = this.descriptorsKeys[this.lastDecodedFieldIdx];
-        debug_check `
-      ${this.lastDecodedFieldIdx < index}
-      Unjustified call to 'decodeUpTo' -
+        debug_check(this.lastDecodedFieldIdx < index, `Unjustified call to 'decodeUpTo' -
        the index ($Blobindex}, ${String(field)})
        is already decoded (${this.lastDecodedFieldIdx}, ${String(lastField)}).
-    `;
+      `);
         let lastItem = this.cache.get(lastField);
         const skipper = new Skipper(this.decoder);
         // now skip all of the fields and further populate the cache.
@@ -30245,10 +30238,8 @@ class ObjectView {
             this.cache.set(field, lastItem);
             this.lastDecodedFieldIdx = i;
         }
-        if (lastItem === undefined) {
-            throw new Error("Last item must be set, since the loop turns at least once.");
-        }
-        return lastItem;
+        const last = ensure(lastItem, lastItem !== undefined, "Last item must be set, since the loop turns at least once.");
+        return last;
     }
 }
 /**
@@ -30281,10 +30272,8 @@ class SequenceView {
     *[Symbol.iterator]() {
         for (let i = 0; i < this.length; i++) {
             const val = this.get(i);
-            if (val === undefined) {
-                throw new Error("We are within 0..this.length so all items are defined.");
-            }
-            yield val;
+            const v = ensure(val, val !== undefined, "We are within 0..this.length so all items are defined.");
+            yield v;
         }
     }
     /** Create an array of all views mapped to some particular value. */
@@ -30327,10 +30316,7 @@ class SequenceView {
         return bytes_BytesBlob.blobFrom(this.decoder.source.subarray(this.initialDecoderOffset, this.decoder.bytesRead()));
     }
     decodeUpTo(index) {
-        debug_check `
-      ${this.lastDecodedIdx < index}
-      Unjustified call to 'decodeUpTo' - the index (${index}) is already decoded (${this.lastDecodedIdx}).
-    `;
+        debug_check(this.lastDecodedIdx < index, `Unjustified call to 'decodeUpTo' - the index (${index}) is already decoded (${this.lastDecodedIdx}).`);
         let lastItem = this.cache.get(this.lastDecodedIdx);
         const skipper = new Skipper(this.decoder);
         // now skip all of the fields and further populate the cache.
@@ -30345,10 +30331,8 @@ class SequenceView {
             this.cache.set(i, lastItem);
             this.lastDecodedIdx = i;
         }
-        if (lastItem === undefined) {
-            throw new Error("Last item must be set, since the loop turns at least once.");
-        }
-        return lastItem;
+        const last = ensure(lastItem, lastItem !== undefined, "Last item must be set, since the loop turns at least once.");
+        return last;
     }
 }
 
@@ -30381,10 +30365,7 @@ const TYPICAL_DICTIONARY_LENGTH = 32;
  */
 function readonlyArray(desc) {
     return desc.convert((x) => {
-        debug_check `
-        ${Array.isArray(x)}
-        Non-arrays are not supported as 'readonly': got ${typeof x}, ${x}
-      `;
+        debug_check(Array.isArray(x), `Non-arrays are not supported as 'readonly': got ${typeof x}, ${x}`);
         // NOTE [ToDr] This assumption is incorrect in general, but it's documented
         // in the general note. We avoid `.slice()` the array for performance reasons.
         return x;
@@ -31339,17 +31320,10 @@ async function initAll() {
 	await init.ed25519();
 	await init.reedSolomon();
 }
-function initOnce(doInit) {
-	let ready = null;
-	return async () => {
-		if (ready === null) ready = doInit();
-		return await ready;
-	};
-}
 const init = {
-	bandersnatch: initOnce(async () => await bandersnatch_default({ module_or_path: await bandersnatch_bg_default() })),
-	ed25519: initOnce(async () => await ed25519_wasm_default({ module_or_path: await ed25519_wasm_bg_default() })),
-	reedSolomon: initOnce(async () => await reed_solomon_wasm_default({ module_or_path: await reed_solomon_wasm_bg_default() }))
+	bandersnatch: async () => await bandersnatch_default({ module_or_path: await bandersnatch_bg_default() }),
+	ed25519: async () => await ed25519_wasm_default({ module_or_path: await ed25519_wasm_bg_default() }),
+	reedSolomon: async () => await reed_solomon_wasm_default({ module_or_path: await reed_solomon_wasm_bg_default() })
 };
 
 //#endregion
@@ -31371,7 +31345,7 @@ const BLS_KEY_BYTES = 144;
 /** Derive a Bandersnatch public key from a seed. */
 function bandersnatch_publicKey(seed) {
     const key = bandersnatch.derive_public_key(seed);
-    check `${key[0] === 0} Invalid Bandersnatch public key derived from seed`;
+    check(key[0] === 0, "Invalid Bandersnatch public key derived from seed");
     return Bytes.fromBlob(key.subarray(1), BANDERSNATCH_KEY_BYTES).asOpaque();
 }
 
@@ -31859,7 +31833,7 @@ async function ed25519_verify(input) {
         data.set(signature.raw, offset);
         offset += ED25519_SIGNATURE_BYTES;
         const messageLength = message.length;
-        debug_check `${messageLength < 256} Message needs to be shorter than 256 bytes. Got: ${messageLength}`;
+        debug_check(messageLength < 256, `Message needs to be shorter than 256 bytes. Got: ${messageLength}`);
         data[offset] = messageLength;
         offset += 1;
         data.set(message.raw, offset);
@@ -31888,7 +31862,6 @@ async function verifyBatch(input) {
 
 ;// CONCATENATED MODULE: ./packages/core/hash/hash.ts
 
-
 /**
  * Size of the output of the hash functions.
  *
@@ -31898,7 +31871,6 @@ async function verifyBatch(input) {
 const hash_HASH_SIZE = 32;
 /** A hash without last byte (useful for trie representation). */
 const TRUNCATED_HASH_SIZE = 31;
-const ZERO_HASH = bytes_Bytes.zero(hash_HASH_SIZE);
 /**
  * Container for some object with a hash that is related to this object.
  *
@@ -31943,7 +31915,7 @@ class PageAllocator {
     // TODO [ToDr] Benchmark the performance!
     constructor(hashesPerPage) {
         this.hashesPerPage = hashesPerPage;
-        check `${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
+        check(hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage, "Expected a non-zero integer.");
         this.resetPage();
     }
     resetPage() {
@@ -32242,8 +32214,8 @@ class MultiMap {
      * if needed.
      */
     constructor(keysLength, keyMappers) {
-        check `${keysLength > 0} Keys cannot be empty.`;
-        check `${keyMappers === undefined || keyMappers.length === keysLength} Incorrect number of key mappers given!`;
+        check(keysLength > 0, "Keys cannot be empty.");
+        check(keyMappers === undefined || keyMappers.length === keysLength, "Incorrect number of key mappers given!");
         this.data = new Map();
         this.keyMappers = keyMappers === undefined ? Array(keysLength).fill(null) : keyMappers;
     }
@@ -32344,7 +32316,7 @@ class sized_array_FixedSizeArray extends Array {
         this.fixedLength = this.length;
     }
     static new(data, len) {
-        debug_check `${data.length === len} Expected an array of size: ${len}, got: ${data.length}`;
+        debug_check(data.length === len, `Expected an array of size: ${len}, got: ${data.length}`);
         const arr = new sized_array_FixedSizeArray(len);
         for (let i = 0; i < len; i++) {
             arr[i] = data[i];
@@ -32478,7 +32450,7 @@ class SortedArray {
     }
     /** Create a new SortedSet from two sorted collections. */
     static fromTwoSortedCollections(first, second) {
-        debug_check `${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
+        debug_check(first.comparator === second.comparator, "Cannot merge arrays if they do not use the same comparator");
         const comparator = first.comparator;
         const arr1 = first.array;
         const arr1Length = arr1.length;
@@ -32598,7 +32570,7 @@ class SortedSet extends SortedArray {
     }
     /** Create a new SortedSet from two sorted collections. */
     static fromTwoSortedCollections(first, second) {
-        debug_check `${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
+        debug_check(first.comparator === second.comparator, "Cannot merge arrays if they do not use the same comparator");
         const comparator = first.comparator;
         if (first.length === 0) {
             return SortedSet.fromSortedArray(comparator, second.array);
@@ -33617,12 +33589,9 @@ const common_tryAsServiceGas = (v) => opaque_asOpaqueType(numbers_tryAsU64(v));
 /** Attempt to convert a number into `CoreIndex`. */
 const common_tryAsCoreIndex = (v) => opaque_asOpaqueType(numbers_tryAsU16(v));
 /** Attempt to convert a number into `Epoch`. */
-const tryAsEpoch = (v) => asOpaqueType(tryAsU32(v));
+const tryAsEpoch = (v) => opaque_asOpaqueType(numbers_tryAsU32(v));
 function tryAsPerValidator(array, spec) {
-    debug_check `
-    ${array.length === spec.validatorsCount}
-    Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}
-  `;
+    debug_check(array.length === spec.validatorsCount, `Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}`);
     return sized_array_asKnownSize(array);
 }
 const codecPerValidator = (val) => codecWithContext((context) => {
@@ -33631,10 +33600,7 @@ const codecPerValidator = (val) => codecWithContext((context) => {
     });
 });
 function tryAsPerEpochBlock(array, spec) {
-    debug_check `
-    ${array.length === spec.epochLength}
-    Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}
-  `;
+    debug_check(array.length === spec.epochLength, `Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}`);
     return sized_array_asKnownSize(array);
 }
 const codecPerEpochBlock = (val) => codecWithContext((context) => {
@@ -33905,14 +33871,9 @@ class WorkItem extends WithDebug {
 
 
 
-
 /** Verify the value is within the `WorkItemsCount` bounds. */
 function work_package_tryAsWorkItemsCount(len) {
-    debug_check `
-    ${len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS}
-    WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${work_package_MAX_NUMBER_OF_WORK_ITEMS}' got ${len}
-  `;
-    return tryAsU8(len);
+    return ensure(len, len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS, `WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${work_package_MAX_NUMBER_OF_WORK_ITEMS}' got ${len}`);
 }
 /** Minimal number of work items in the work package or results in work report. */
 const MIN_NUMBER_OF_WORK_ITEMS = 1;
@@ -35886,10 +35847,7 @@ class AvailabilityAssignment extends WithDebug {
 
 /** Check if given array has correct length before casting to the opaque type. */
 function tryAsPerCore(array, spec) {
-    debug_check `
-    ${array.length === spec.coresCount}
-    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
-  `;
+    debug_check(array.length === spec.coresCount, `Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}`);
     return opaque_asOpaqueType(array);
 }
 const codecPerCore = (val) => codecWithContext((context) => {
@@ -37140,7 +37098,7 @@ class InMemoryState extends WithDebug {
     }
     removeServices(servicesRemoved) {
         for (const serviceId of servicesRemoved ?? []) {
-            debug_check `${this.services.has(serviceId)} Attempting to remove non-existing service: ${serviceId}`;
+            debug_check(this.services.has(serviceId), `Attempting to remove non-existing service: ${serviceId}`);
             this.services.delete(serviceId);
         }
     }
@@ -37157,10 +37115,7 @@ class InMemoryState extends WithDebug {
             }
             else if (kind === UpdateStorageKind.Remove) {
                 const { key } = action;
-                debug_check `
-          ${service.data.storage.has(key.toString())}
-          Attempting to remove non-existing storage item at ${serviceId}: ${action.key}
-        `;
+                debug_check(service.data.storage.has(key.toString()), `Attempting to remove non-existing storage item at ${serviceId}: ${action.key}`);
                 service.data.storage.delete(key.toString());
             }
             else {
@@ -37843,12 +37798,12 @@ class TrieNode {
     }
     /** View this node as a branch node */
     asBranchNode() {
-        debug_check `${this.getNodeType() === NodeType.Branch} not a branch!`;
+        debug_check(this.getNodeType() === NodeType.Branch);
         return new BranchNode(this);
     }
     /** View this node as a leaf node */
     asLeafNode() {
-        debug_check `${this.getNodeType() !== NodeType.Branch} not a leaf!`;
+        debug_check(this.getNodeType() !== NodeType.Branch);
         return new LeafNode(this);
     }
     toString() {
@@ -38336,7 +38291,7 @@ function createSubtreeForBothLeaves(traversedPath, nodes, leafToReplace, leaf) {
  * Return a single bit from `key` located at `bitIndex`.
  */
 function getBit(key, bitIndex) {
-    debug_check `${bitIndex < TRUNCATED_KEY_BITS} invalid bit index passed ${bitIndex}`;
+    debug_check(bitIndex < TRUNCATED_KEY_BITS);
     const byte = bitIndex >>> 3;
     const bit = bitIndex - (byte << 3);
     const mask = 0b10_00_00_00 >>> bit;
@@ -39496,7 +39451,7 @@ class TypedPort {
      * Send a response given the worker that has previously requested something.
      */
     respond(localState, request, data, transferList) {
-        debug_check `${request.kind === "request"}`;
+        debug_check(request.kind === "request");
         this.postMessage({
             kind: "response",
             id: request.id,
@@ -39527,11 +39482,10 @@ class TypedPort {
             throw new Error(`Invalid message: ${JSON.stringify(msg)}.`);
         }
         switch (msg.kind) {
-            case "response": {
-                debug_check `${this.responseListeners.eventNames().indexOf(reqEvent(msg.id)) !== -1}`;
+            case "response":
+                debug_check(this.responseListeners.eventNames().indexOf(reqEvent(msg.id)) !== -1);
                 this.responseListeners.emit(reqEvent(msg.id), null, msg.data, msg.name, msg.localState, msg);
                 break;
-            }
             case "signal":
                 this.listeners.emit("signal", msg.name, msg.data, msg.localState, msg);
                 break;
@@ -39746,9 +39700,9 @@ class MessageChannelStateMachine {
         const promise = new Promise((resolve, reject) => {
             parentPort.once("message", (value) => {
                 try {
-                    debug_check `${value.kind === "request"} The initial message should be a request with channel.`;
-                    debug_check `${value.name === CHANNEL_MESSAGE}`;
-                    debug_check `${value.data instanceof external_node_worker_threads_namespaceObject.MessagePort}`;
+                    debug_check(value.kind === "request", "The initial message should be a request with channel.");
+                    debug_check(value.name === CHANNEL_MESSAGE);
+                    debug_check(value.data instanceof external_node_worker_threads_namespaceObject.MessagePort);
                     const port = new TypedPort(value.data);
                     port.respond(machine.currentState().stateName, value, Ok);
                     resolve(port);
@@ -39828,7 +39782,7 @@ class StateMachine {
     /** Get state object by name. */
     getState(name) {
         const state = this.allStates.get(name);
-        debug_check `${state !== undefined} Unable to retrieve state object for ${name}.`;
+        debug_check(state !== undefined, `Unable to retrieve state object for ${name}.`);
         return state;
     }
     /** Get the currently active state object. */
@@ -40223,6 +40177,7 @@ class ImporterReady extends State {
             response: rootHash === null ? bytes_Bytes.zero(hash_HASH_SIZE).raw : rootHash.raw,
         };
     }
+    // NOTE [ToDr] This should rather be using the import queue, instead of going directly.
     async importBlock(block) {
         if (this.importer === null) {
             state_machine_logger.error(`${this.constructor.name} importer not initialized yet!`);
@@ -40234,13 +40189,17 @@ class ImporterReady extends State {
         if (block instanceof Uint8Array) {
             const config = this.getConfig();
             const blockView = decoder_Decoder.decodeObject(Block.Codec.View, block, config.chainSpec);
+            const headerView = blockView.header.view();
+            const timeSlot = headerView.timeSlotIndex.materialize();
             let response;
             try {
-                const res = await this.importer.importBlock(blockView, config.omitSealVerification);
+                const res = await this.importer.importBlock(blockView, null, config.omitSealVerification);
                 if (res.isOk) {
-                    response = result_Result.ok(this.importer.getBestStateRootHash() ?? ZERO_HASH.asOpaque());
+                    state_machine_logger.info(`🧊 Best block: #${timeSlot} (${res.ok.hash})`);
+                    response = result_Result.ok(this.importer.getBestStateRootHash() ?? bytes_Bytes.zero(hash_HASH_SIZE).asOpaque());
                 }
                 else {
+                    state_machine_logger.log(`❌ Rejected block #${timeSlot}: ${resultToString(res)}`);
                     response = result_Result.error(resultToString(res));
                 }
             }
@@ -40561,22 +40520,19 @@ class Preimages {
 
 const NO_OF_REGISTERS = 13;
 const REGISTER_SIZE_SHIFT = 3;
-const tryAsRegisterIndex = (index) => {
-    debug_check `${index >= 0 && index < NO_OF_REGISTERS} Incorrect register index: ${index}!`;
-    return opaque_asOpaqueType(index);
-};
+const tryAsRegisterIndex = (index) => ensure(index, index >= 0 && index <= NO_OF_REGISTERS, `Incorrect register index: ${index}!`);
 class Registers {
     bytes;
     asSigned;
     asUnsigned;
     constructor(bytes = new Uint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
         this.bytes = bytes;
-        debug_check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+        debug_check(bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT, "Invalid size of registers array.");
         this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
         this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
     }
     static fromBytes(bytes) {
-        debug_check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+        debug_check(bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT, "Invalid size of registers array.");
         return new Registers(bytes);
     }
     getBytesAsLittleEndian(index, len) {
@@ -40722,7 +40678,7 @@ class Mask {
         return this.lookupTableForward[index] === 0;
     }
     getNoOfBytesToNextInstruction(index) {
-        debug_check `${index >= 0} index (${index}) cannot be a negative number`;
+        debug_check(index >= 0, `index (${index}) cannot be a negative number`);
         return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
     }
     buildLookupTableForward(mask) {
@@ -41722,7 +41678,7 @@ const PAGE_SIZE_SHIFT = 12;
 const PAGE_SIZE = 1 << PAGE_SIZE_SHIFT;
 const MIN_ALLOCATION_SHIFT = (() => {
     const MIN_ALLOCATION_SHIFT = 7;
-    debug_check `${MIN_ALLOCATION_SHIFT >= 0 && MIN_ALLOCATION_SHIFT < PAGE_SIZE_SHIFT} incorrect minimal allocation shift`;
+    debug_check(MIN_ALLOCATION_SHIFT >= 0 && MIN_ALLOCATION_SHIFT < PAGE_SIZE_SHIFT, "incorrect minimal allocation shift");
     return MIN_ALLOCATION_SHIFT;
 })();
 const MIN_ALLOCATION_LENGTH = PAGE_SIZE >> MIN_ALLOCATION_SHIFT;
@@ -41735,28 +41691,16 @@ const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / PAGE_SIZE;
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-index.ts
 
 
-const tryAsMemoryIndex = (index) => {
-    debug_check `${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
-    return opaque_asOpaqueType(index);
-};
-const tryAsSbrkIndex = (index) => {
-    debug_check `${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
-    return opaque_asOpaqueType(index);
-};
+const tryAsMemoryIndex = (index) => ensure(index, index >= 0 && index <= MAX_MEMORY_INDEX, `Incorrect memory index: ${index}!`);
+const tryAsSbrkIndex = (index) => ensure(index, index >= 0 && index <= MAX_MEMORY_INDEX + 1, `Incorrect sbrk index: ${index}!`);
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/page-utils.ts
 
 
 /** Ensure that given memory `index` is within `[0...PAGE_SIZE)` and can be used to index a page */
-const tryAsPageIndex = (index) => {
-    debug_check `${index >= 0 && index < PAGE_SIZE}, Incorect page index: ${index}!`;
-    return opaque_asOpaqueType(index);
-};
+const tryAsPageIndex = (index) => ensure(index, index >= 0 && index < PAGE_SIZE, `Incorect page index: ${index}!`);
 /** Ensure that given `index` represents an index of one of the pages. */
-const tryAsPageNumber = (index) => {
-    debug_check `${index >= 0 && index <= LAST_PAGE_NUMBER}, Incorect page number: ${index}!`;
-    return opaque_asOpaqueType(index);
-};
+const tryAsPageNumber = (index) => ensure(index, index >= 0 && index <= LAST_PAGE_NUMBER, `Incorrect page number: ${index}!`);
 /**
  * Get the next page number and wrap the result if it is bigger than LAST_PAGE_NUMBER
  *
@@ -42288,10 +42232,10 @@ class MemoryBuilder {
      */
     setReadablePages(start, end, data = new Uint8Array()) {
         this.ensureNotFinalized();
-        debug_check `${start < end} end has to be bigger than start`;
-        debug_check `${start % PAGE_SIZE === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-        debug_check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
-        debug_check `${data.length <= end - start} the initial data is longer than address range`;
+        debug_check(start < end, "end has to be bigger than start");
+        debug_check(start % PAGE_SIZE === 0, `start needs to be a multiple of page size (${PAGE_SIZE})`);
+        debug_check(end % PAGE_SIZE === 0, `end needs to be a multiple of page size (${PAGE_SIZE})`);
+        debug_check(data.length <= end - start, "the initial data is longer than address range");
         const length = end - start;
         const range = MemoryRange.fromStartAndLength(start, length);
         this.ensureNoReservedMemoryUsage(range);
@@ -42316,10 +42260,10 @@ class MemoryBuilder {
      */
     setWriteablePages(start, end, data = new Uint8Array()) {
         this.ensureNotFinalized();
-        debug_check `${start < end} end has to be bigger than start`;
-        debug_check `${start % PAGE_SIZE === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-        debug_check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
-        debug_check `${data.length <= end - start} the initial data is longer than address range`;
+        debug_check(start < end, "end has to be bigger than start");
+        debug_check(start % PAGE_SIZE === 0, `start needs to be a multiple of page size (${PAGE_SIZE})`);
+        debug_check(end % PAGE_SIZE === 0, `end needs to be a multiple of page size (${PAGE_SIZE})`);
+        debug_check(data.length <= end - start, "the initial data is longer than address range");
         const length = end - start;
         const range = MemoryRange.fromStartAndLength(start, length);
         this.ensureNoReservedMemoryUsage(range);
@@ -42341,7 +42285,7 @@ class MemoryBuilder {
         this.ensureNotFinalized();
         const pageOffset = start % PAGE_SIZE;
         const remainingSpaceOnPage = PAGE_SIZE - pageOffset;
-        debug_check `${data.length <= remainingSpaceOnPage} The data has to fit into a single page.`;
+        debug_check(data.length <= remainingSpaceOnPage, "The data has to fit into a single page.");
         const length = data.length;
         const range = MemoryRange.fromStartAndLength(start, length);
         this.ensureNoReservedMemoryUsage(range);
@@ -42355,10 +42299,7 @@ class MemoryBuilder {
         return this;
     }
     finalize(startHeapIndex, endHeapIndex) {
-        debug_check `
-      ${startHeapIndex <= endHeapIndex}
-      startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
-    `;
+        debug_check(startHeapIndex <= endHeapIndex, `startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})`);
         this.ensureNotFinalized();
         const range = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
         const pages = PageRange.fromMemoryRange(range);
@@ -42596,7 +42537,7 @@ function mulU64(a, b) {
  *
  * The result of multiplication is a 64-bits number and we are only interested in the part that lands in the upper 32-bits.
  * For example if we multiply `0xffffffff * 0xffffffff`, we get:
-
+ 
  * |       64-bits      |       64-bits      |
  * +--------------------+--------------------+
  * |        upper       |        lower       |
@@ -42632,7 +42573,7 @@ function mulUpperSS(a, b) {
     return interpretAsSigned(resultLimitedTo64Bits);
 }
 function unsignedRightShiftBigInt(value, shift) {
-    debug_check `${shift >= 0} Shift count must be non-negative`;
+    debug_check(shift >= 0, "Shift count must be non-negative");
     const fillBit = value < 0 ? "1" : "0";
     // Convert the BigInt to its binary representation
     const binaryRepresentation = value.toString(2).padStart(64, fillBit);
@@ -44048,10 +43989,7 @@ class TwoRegsTwoImmsDispatcher {
 class JumpTable {
     indices;
     constructor(itemByteLength, bytes) {
-        debug_check `
-      ${itemByteLength === 0 || bytes.length % itemByteLength === 0}
-      Length of jump table (${bytes.length}) should be a multiple of item lenght (${itemByteLength})!
-    `;
+        debug_check(itemByteLength === 0 || bytes.length % itemByteLength === 0, `Length of jump table (${bytes.length}) should be a multiple of item lenght (${itemByteLength})!`);
         const length = itemByteLength === 0 ? 0 : bytes.length / itemByteLength;
         this.indices = new Uint32Array(length);
         for (let i = 0; i < length; i++) {
@@ -44495,10 +44433,7 @@ class ReturnValue {
         this.consumedGas = consumedGas;
         this.status = status;
         this.memorySlice = memorySlice;
-        debug_check `
-      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
-      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
-    `;
+        debug_check((status === null && memorySlice !== null) || (status !== null && memorySlice === null), "`status` and `memorySlice` must not both be null or both be non-null — exactly one must be provided");
     }
     static fromStatus(consumedGas, status) {
         return new ReturnValue(consumedGas, status, null);
@@ -44547,10 +44482,7 @@ class HostCalls {
             if (status !== status_Status.HOST) {
                 return this.getReturnValue(status, pvmInstance);
             }
-            debug_check `
-        ${pvmInstance.getExitParam() !== null}
-        "We know that the exit param is not null, because the status is 'Status.HOST'
-      `;
+            debug_check(pvmInstance.getExitParam() !== null, "We know that the exit param is not null, because the status is `Status.HOST`");
             const hostCallIndex = pvmInstance.getExitParam() ?? -1;
             const gas = pvmInstance.getGasCounter();
             const regs = new HostCallRegisters(pvmInstance.getRegisters());
@@ -44610,7 +44542,7 @@ class host_calls_manager_HostCallsManager {
     constructor({ missing, handlers = [], }) {
         this.missing = missing;
         for (const handler of handlers) {
-            debug_check `${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
+            debug_check(this.hostCalls.get(handler.index) === undefined, `Overwriting host call handler at index ${handler.index}`);
             this.hostCalls.set(handler.index, handler);
         }
     }
@@ -44733,7 +44665,7 @@ function getServiceId(serviceId) {
     return null;
 }
 function writeServiceIdAsLeBytes(serviceId, destination) {
-    debug_check `${destination.length >= SERVICE_ID_BYTES} Not enough space in the destination.`;
+    debug_check(destination.length >= SERVICE_ID_BYTES, "Not enough space in the destination.");
     destination.set(numbers_u32AsLeBytes(serviceId));
 }
 /** Clamp a U64 to the maximum value of a 32-bit unsigned integer. */
@@ -44822,27 +44754,13 @@ class SpiProgram extends WithDebug {
         this.registers = registers;
     }
 }
-/**
- * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
- *
- * E_n - little endian encoding, n - length
- * o - initial read only data
- * w - initial heap
- * z - heap pages filled with zeros
- * s - stack size
- * c - program code
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
- */
 function decodeStandardProgram(program, args) {
     const decoder = decoder_Decoder.fromBlob(program);
     const oLength = decoder.u24();
     const wLength = decoder.u24();
-    debug_check `${args.length <= DATA_LEGNTH} Incorrect arguments length`;
-    debug_check `${oLength <= DATA_LEGNTH} Incorrect readonly segment length`;
-    const readOnlyLength = oLength;
-    debug_check `${wLength <= DATA_LEGNTH} Incorrect heap segment length`;
-    const heapLength = wLength;
+    const argsLength = ensure(args.length, args.length <= DATA_LEGNTH, "Incorrect arguments length");
+    const readOnlyLength = ensure(oLength, oLength <= DATA_LEGNTH, "Incorrect readonly segment length");
+    const heapLength = ensure(wLength, wLength <= DATA_LEGNTH, "Incorrect heap segment length");
     const noOfHeapZerosPages = decoder.u16();
     const stackSize = decoder.u24();
     const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
@@ -44858,14 +44776,14 @@ function decodeStandardProgram(program, args) {
     const stackStart = STACK_SEGMENT - memory_utils_alignToPageSize(stackSize);
     const stackEnd = STACK_SEGMENT;
     const argsStart = ARGS_SEGMENT;
-    const argsEnd = argsStart + memory_utils_alignToPageSize(args.length);
-    const argsZerosEnd = argsEnd + memory_utils_alignToPageSize(args.length);
+    const argsEnd = argsStart + memory_utils_alignToPageSize(argsLength);
+    const argsZerosEnd = argsEnd + memory_utils_alignToPageSize(argsLength);
     function nonEmpty(s) {
         return s !== false;
     }
     const readableMemory = [
         readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
-        args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
+        argsLength > 0 && getMemorySegment(argsStart, argsEnd, args),
         argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
     ].filter(nonEmpty);
     const writeableMemory = [
@@ -57659,6 +57577,88 @@ const initNetwork = async (importerReady, workerConfig, genesisHeaderHash, netwo
 ;// CONCATENATED MODULE: external "node:fs/promises"
 const external_node_fs_promises_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs/promises");
 var external_node_fs_promises_default = /*#__PURE__*/__nccwpck_require__.n(external_node_fs_promises_namespaceObject);
+;// CONCATENATED MODULE: ./workers/importer/import-queue.ts
+
+
+
+
+
+class ImportQueue {
+    spec;
+    importer;
+    toImport = SortedArray.fromSortedArray((a, b) => {
+        const diff = a.timeSlot - b.timeSlot;
+        if (diff < 0) {
+            return Ordering.Greater;
+        }
+        if (diff > 0) {
+            return Ordering.Less;
+        }
+        return Ordering.Equal;
+    });
+    queuedBlocks = HashSet.new();
+    lastEpoch = tryAsEpoch(2 ** 32 - 1);
+    constructor(spec, importer) {
+        this.spec = spec;
+        this.importer = importer;
+    }
+    isCurrentEpoch(timeSlot) {
+        const epoch = Math.floor(timeSlot / this.spec.epochLength);
+        return this.lastEpoch === epoch;
+    }
+    startPreverification() {
+        for (const entry of this.toImport) {
+            if (this.isCurrentEpoch(entry.timeSlot)) {
+                entry.seal = this.importer.preverifySeal(entry.timeSlot, entry.block);
+            }
+        }
+    }
+    static getBlockDetails(block) {
+        let encodedHeader;
+        let timeSlot;
+        try {
+            encodedHeader = block.header.encoded();
+            timeSlot = block.header.view().timeSlotIndex.materialize();
+        }
+        catch {
+            return result_Result.error("invalid");
+        }
+        const headerHash = hashBytes(encodedHeader).asOpaque();
+        return result_Result.ok(new WithHash(headerHash, { block, timeSlot }));
+    }
+    push(details) {
+        const headerHash = details.hash;
+        if (this.queuedBlocks.has(headerHash)) {
+            return result_Result.error("already queued");
+        }
+        const { timeSlot, block } = details.data;
+        const entry = {
+            headerHash,
+            timeSlot,
+            block,
+            seal: this.isCurrentEpoch(timeSlot) ? this.importer.preverifySeal(timeSlot, block) : Promise.resolve(null),
+        };
+        this.toImport.insert(entry);
+        this.queuedBlocks.insert(headerHash);
+        return result_Result.ok(result_OK);
+    }
+    shift() {
+        const entry = this.toImport.pop();
+        if (entry !== undefined) {
+            this.queuedBlocks.delete(entry.headerHash);
+            const blockEpoch = Math.floor(entry.timeSlot / this.spec.epochLength);
+            const hasEpochChanged = this.lastEpoch !== blockEpoch;
+            this.lastEpoch = tryAsEpoch(blockEpoch);
+            // currently removed block is changing the epoch, so fire up
+            // preverifcation for the following blocks.
+            if (hasEpochChanged) {
+                this.startPreverification();
+            }
+        }
+        return entry;
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/jam/transition/block-verifier.ts
 
 
@@ -57672,7 +57672,7 @@ var BlockVerifierError;
     BlockVerifierError[BlockVerifierError["InvalidStateRoot"] = 4] = "InvalidStateRoot";
     BlockVerifierError[BlockVerifierError["AlreadyImported"] = 5] = "AlreadyImported";
 })(BlockVerifierError || (BlockVerifierError = {}));
-const block_verifier_ZERO_HASH = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
+const ZERO_HASH = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
 class BlockVerifier {
     hasher;
     blocks;
@@ -57692,7 +57692,7 @@ class BlockVerifier {
         // https://graypaper.fluffylabs.dev/#/cc517d7/0c9d000c9d00?v=0.6.5
         const parentHash = headerView.parentHeaderHash.materialize();
         // importing genesis block
-        if (!parentHash.isEqualTo(block_verifier_ZERO_HASH)) {
+        if (!parentHash.isEqualTo(ZERO_HASH)) {
             const parentBlock = this.blocks.getHeader(parentHash);
             if (parentBlock === null) {
                 return result_Result.error(BlockVerifierError.ParentNotFound, `Parent ${parentHash.toString()} not found`);
@@ -58205,22 +58205,301 @@ async function verifyTickets(bandersnatch, numberOfValidators, epochRoot, ticket
     }));
 }
 
-;// CONCATENATED MODULE: ./packages/jam/safrole/bandersnatch-wasm.ts
+;// CONCATENATED MODULE: ./packages/core/concurrent/parent.ts
+
+
+// Amount of tasks in the queue that will trigger creation of new worker thread.
+// NOTE this might need to be configurable in the future.
+const QUEUE_SIZE_WORKER_THRESHOLD = 5;
+/** Execution pool manager. */
+class Executor {
+    workers;
+    maxWorkers;
+    workerPath;
+    /** Initialize a new concurrent executor given a path to the worker. */
+    static async initialize(workerPath, options) {
+        debug_check(options.maxWorkers > 0, "Max workers has to be positive.");
+        debug_check(options.minWorkers <= options.maxWorkers, "Min workers has to be lower or equal to max workers.");
+        const workers = [];
+        for (let i = 0; i < options.minWorkers; i++) {
+            workers.push(await initWorker(workerPath));
+        }
+        return new Executor(workers, options.maxWorkers, workerPath);
+    }
+    // keeps track of the indices of worker threads that are currently free and available to execute tasks
+    freeWorkerIndices = [];
+    taskQueue = [];
+    isDestroyed = false;
+    isWorkerInitializing = false;
+    constructor(workers, maxWorkers, workerPath) {
+        this.workers = workers;
+        this.maxWorkers = maxWorkers;
+        this.workerPath = workerPath;
+        // intial free workers.
+        for (let i = 0; i < workers.length; i++) {
+            this.freeWorkerIndices.push(i);
+        }
+    }
+    /** Attempt to initialize a new worker. */
+    async initNewWorker(onSuccess = () => { }) {
+        if (this.workers.length >= this.maxWorkers) {
+            // biome-ignore lint/suspicious/noConsole: warning
+            console.warn(`Task queue has ${this.taskQueue.length} pending items and we can't init any more workers.`);
+            return;
+        }
+        if (this.isWorkerInitializing) {
+            return;
+        }
+        this.isWorkerInitializing = true;
+        this.workers.push(await initWorker(this.workerPath));
+        this.freeWorkerIndices.push(this.workers.length - 1);
+        this.isWorkerInitializing = false;
+        onSuccess();
+    }
+    /** Terminate all workers and clear the executor. */
+    async destroy() {
+        for (const worker of this.workers) {
+            worker.port.close();
+            await worker.worker.terminate();
+        }
+        this.workers.length = 0;
+        this.isDestroyed = true;
+    }
+    /** Execute a task with given parameters. */
+    async run(params) {
+        return new Promise((resolve, reject) => {
+            if (this.isDestroyed) {
+                reject("pool destroyed");
+                return;
+            }
+            this.taskQueue.push({
+                params,
+                resolve,
+                reject,
+            });
+            this.processEntryFromTaskQueue();
+        });
+    }
+    /** Process single element from the task queue. */
+    processEntryFromTaskQueue() {
+        const freeWorker = this.freeWorkerIndices.pop();
+        // no free workers available currently,
+        // we will retry when one of the tasks completes.
+        if (freeWorker === undefined) {
+            if (this.taskQueue.length > QUEUE_SIZE_WORKER_THRESHOLD) {
+                this.initNewWorker(() => {
+                    // process an entry in this newly initialized worker.
+                    this.processEntryFromTaskQueue();
+                });
+            }
+            return;
+        }
+        const task = this.taskQueue.pop();
+        // no tasks in the queue
+        if (task === undefined) {
+            this.freeWorkerIndices.push(freeWorker);
+            return;
+        }
+        const worker = this.workers[freeWorker];
+        worker.runTask(task, () => {
+            // mark the worker as available again
+            this.freeWorkerIndices.push(freeWorker);
+            // and continue processing the queue
+            this.processEntryFromTaskQueue();
+        });
+    }
+}
+async function initWorker(workerPath) {
+    // create a worker and initialize communication channel
+    const { port1, port2 } = new MessageChannel();
+    const workerThread = new external_node_worker_threads_namespaceObject.Worker(workerPath, {});
+    workerThread.postMessage(port1, [port1]);
+    // // wait for the worker to start
+    await new Promise((resolve, reject) => {
+        workerThread.once("message", resolve);
+        workerThread.once("error", reject);
+    });
+    // make sure the threads don't prevent the program from stopping.
+    workerThread.unref();
+    return new WorkerChannel(workerThread, port2);
+}
+class WorkerChannel {
+    worker;
+    port;
+    constructor(worker, port) {
+        this.worker = worker;
+        this.port = port;
+    }
+    runTask(task, onFinish) {
+        const message = {
+            params: task.params,
+        };
+        // when we receive a response, make sure to process it
+        this.port.once("message", (e) => {
+            if (e.isOk) {
+                task.resolve(e.ok);
+            }
+            else {
+                task.reject(new Error(e.error));
+            }
+            onFinish();
+        });
+        // send the task to work on.
+        this.port.postMessage(message, message.params.getTransferList());
+    }
+}
 
+;// CONCATENATED MODULE: ./packages/core/concurrent/worker.ts
+
+
+/** A in-worker abstraction. */
+class ConcurrentWorker {
+    runInternal;
+    state;
+    static new(run, state) {
+        return new ConcurrentWorker(run, state);
+    }
+    constructor(runInternal, state) {
+        this.runInternal = runInternal;
+        this.state = state;
+    }
+    listenToParentPort() {
+        if (external_node_worker_threads_namespaceObject.parentPort === null) {
+            throw new Error("This method is meant to be run inside a worker thread!");
+        }
+        external_node_worker_threads_namespaceObject.parentPort.once("close", () => {
+            process.exit(0);
+        });
+        external_node_worker_threads_namespaceObject.parentPort.once("message", (port) => {
+            this.listenTo(port);
+            // send back readiness signal.
+            external_node_worker_threads_namespaceObject.parentPort?.postMessage("ready");
+        });
+    }
+    listenTo(port) {
+        port.once("close", () => {
+            port.removeAllListeners();
+            process.exit(0);
+        });
+        port.on("message", (ev) => {
+            const { params } = ev;
+            this.run(params)
+                .then((result) => {
+                const response = result_Result.ok(result);
+                port.postMessage(response, result.getTransferList());
+            })
+                .catch((e) => {
+                const response = result_Result.error(`${e}`);
+                port.postMessage(response, []);
+            });
+        });
+    }
+    async run(params) {
+        return await this.runInternal(params, this.state);
+    }
+    async destroy() { }
+}
+
+;// CONCATENATED MODULE: ./packages/core/concurrent/index.ts
+
+
+
+;// CONCATENATED MODULE: ./packages/jam/safrole/bandersnatch-wasm/params.ts
+var Method;
+(function (Method) {
+    Method[Method["RingCommitment"] = 0] = "RingCommitment";
+    Method[Method["BatchVerifyTickets"] = 1] = "BatchVerifyTickets";
+    Method[Method["VerifySeal"] = 2] = "VerifySeal";
+})(Method || (Method = {}));
+class params_Response {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    getTransferList() {
+        return [this.data.buffer];
+    }
+}
+class Params {
+    params;
+    constructor(params) {
+        this.params = params;
+    }
+    getTransferList() {
+        return [];
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/jam/safrole/bandersnatch-wasm/worker.ts
+
+
+
+
+const worker = ConcurrentWorker.new(async (p) => {
+    await initAll();
+    const params = p.params;
+    const method = params.method;
+    if (method === Method.RingCommitment) {
+        return Promise.resolve(new params_Response(bandersnatch_exports.ring_commitment(params.keys)));
+    }
+    if (method === Method.BatchVerifyTickets) {
+        return Promise.resolve(new params_Response(bandersnatch_exports.batch_verify_tickets(params.ringSize, params.commitment, params.ticketsData, params.contextLength)));
+    }
+    if (method === Method.VerifySeal) {
+        return Promise.resolve(new params_Response(bandersnatch_exports.verify_seal(params.authorKey, params.signature, params.payload, params.auxData)));
+    }
+    debug_assertNever(method);
+}, null);
+
+;// CONCATENATED MODULE: ./packages/jam/safrole/bandersnatch-wasm/index.ts
+
+
+
+
+const bandersnatch_wasm_workerFile = __nccwpck_require__.ab + "bootstrap-bandersnatch.mjs";
 class BandernsatchWasm {
-    constructor() { }
-    static async new() {
-        await initAll();
-        return new BandernsatchWasm();
+    executor;
+    constructor(executor) {
+        this.executor = executor;
+    }
+    destroy() {
+        return this.executor.destroy();
+    }
+    static async new({ synchronous }) {
+        const workers = external_node_os_default().cpus().length;
+        return new BandernsatchWasm(!synchronous
+            ? await Executor.initialize(bandersnatch_wasm_workerFile, {
+                minWorkers: Math.max(1, Math.floor(workers / 2)),
+                maxWorkers: workers,
+            })
+            : worker);
     }
     async verifySeal(authorKey, signature, payload, auxData) {
-        return bandersnatch_exports.verify_seal(authorKey, signature, payload, auxData);
+        const x = await this.executor.run(new Params({
+            method: Method.VerifySeal,
+            authorKey,
+            signature,
+            payload,
+            auxData,
+        }));
+        return x.data;
     }
     async getRingCommitment(keys) {
-        return bandersnatch_exports.ring_commitment(keys);
+        const x = await this.executor.run(new Params({
+            method: Method.RingCommitment,
+            keys,
+        }));
+        return x.data;
     }
     async batchVerifyTicket(ringSize, commitment, ticketsData, contextLength) {
-        return bandersnatch_exports.batch_verify_tickets(ringSize, commitment, ticketsData, contextLength);
+        const x = await this.executor.run(new Params({
+            method: Method.BatchVerifyTickets,
+            ringSize,
+            commitment,
+            ticketsData,
+            contextLength,
+        }));
+        return x.data;
     }
 }
 
@@ -58263,7 +58542,7 @@ class Safrole {
     chainSpec;
     state;
     bandersnatch;
-    constructor(chainSpec, state, bandersnatch = BandernsatchWasm.new()) {
+    constructor(chainSpec, state, bandersnatch = BandernsatchWasm.new({ synchronous: true })) {
         this.chainSpec = chainSpec;
         this.state = state;
         this.bandersnatch = bandersnatch;
@@ -58641,7 +58920,7 @@ var SafroleSealError;
 const BANDERSNATCH_ZERO_KEY = bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque();
 class SafroleSeal {
     bandersnatch;
-    constructor(bandersnatch = BandernsatchWasm.new()) {
+    constructor(bandersnatch = BandernsatchWasm.new({ synchronous: true })) {
         this.bandersnatch = bandersnatch;
     }
     /**
@@ -58953,8 +59232,8 @@ class PartiallyUpdatedState {
         this.stateUpdate.services.preimages.push(newUpdate);
     }
     updateServiceStorageUtilisation(serviceId, items, bytes, serviceInfo) {
-        debug_check `${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
-        debug_check `${bytes >= 0} storageUtilisationBytes has to be a positive number, got: ${bytes}`;
+        debug_check(items >= 0, `storageUtilisationCount has to be a positive number, got: ${items}`);
+        debug_check(bytes >= 0, `storageUtilisationBytes has to be a positive number, got: ${bytes}`);
         const overflowItems = !isU32(items);
         const overflowBytes = !isU64(bytes);
         // TODO [ToDr] this is not specified in GP, but it seems sensible.
@@ -59379,7 +59658,7 @@ class AccumulateExternalities {
             }
             // TODO [ToDr] Not sure if we should update the service info in that case,
             // but for now we let that case fall-through.
-            debug_check `${len === PreimageStatusKind.Unavailable} preimage is not unavailable`;
+            debug_check(len === PreimageStatusKind.Unavailable);
         }
         // make sure we have enough balance for this update
         // https://graypaper.fluffylabs.dev/#/9a08063/381201381601?v=0.6.6
@@ -59875,7 +60154,7 @@ class Assurances {
                 return result_Result.error(AssurancesError.InvalidOrder, `order: expected: ${prevValidatorIndex + 1}, got: ${validatorIndex}`);
             }
             prevValidatorIndex = assurance.validatorIndex;
-            debug_check `${bitfield.bitLength === coresCount} Invalid bitfield length of ${bitfield.bitLength}`;
+            debug_check(bitfield.bitLength === coresCount, `Invalid bitfield length of ${bitfield.bitLength}`);
             const setBits = bitfield.indicesOfSetBits();
             for (const idx of setBits) {
                 perCoreAssurances[idx] += 1;
@@ -62199,7 +62478,7 @@ class DeferredTransfers {
             transferStatistics.set(serviceId, { count: numbers_tryAsU32(transfers.length), gasUsed: common_tryAsServiceGas(consumedGas) });
             const [updatedState, checkpointedState] = partialState.getStateUpdates();
             currentStateUpdate = updatedState;
-            debug_check `${checkpointedState === null} On transfer cannot invoke checkpoint.`;
+            debug_check(checkpointedState === null, "On transfer cannot invoke checkpoint.");
         }
         return result_Result.ok({
             // NOTE: we return only services, since it's impossible to update
@@ -62537,7 +62816,7 @@ const ENTROPY_BYTES = 32;
  * https://graypaper.fluffylabs.dev/#/579bd12/3b9a013b9a01
  */
 function fisherYatesShuffle(arr, entropy) {
-    debug_check `${entropy.length === ENTROPY_BYTES} Expected entropy of length ${ENTROPY_BYTES}, got ${entropy.length}`;
+    debug_check(entropy.length === ENTROPY_BYTES, `Expected entropy of length ${ENTROPY_BYTES}, got ${entropy.length}`);
     const n = arr.length;
     const randomNumbers = hashToNumberSequence(entropy, arr.length);
     const result = new Array(n);
@@ -63384,7 +63663,7 @@ class Statistics {
         /** get statistics for the current epoch */
         const statistics = this.getStatistics(slot);
         const { current, cores, services } = statistics;
-        debug_check `${current[authorIndex] !== undefined} authorIndex is out of bounds`;
+        debug_check(current[authorIndex] !== undefined, "authorIndex is out of bounds");
         /** One validator can produce maximal one block per timeslot */
         const newBlocksCount = current[authorIndex].blocks + 1;
         current[authorIndex].blocks = numbers_tryAsU32(newBlocksCount);
@@ -63584,11 +63863,11 @@ class OnChain {
     authorization;
     // chapter 13: https://graypaper.fluffylabs.dev/#/68eaa1f/18b60118b601?v=0.6.4
     statistics;
-    constructor(chainSpec, state, blocks, hasher) {
+    constructor(chainSpec, state, blocks, hasher, { enableParallelSealVerification }) {
         this.chainSpec = chainSpec;
         this.state = state;
         this.hasher = hasher;
-        const bandersnatch = BandernsatchWasm.new();
+        const bandersnatch = BandernsatchWasm.new({ synchronous: !enableParallelSealVerification });
         this.statistics = new Statistics(chainSpec, state);
         this.safrole = new Safrole(chainSpec, state, bandersnatch);
         this.safroleSeal = new SafroleSeal(bandersnatch);
@@ -63606,16 +63885,16 @@ class OnChain {
         const sealState = this.safrole.getSafroleSealState(timeSlot);
         return await this.safroleSeal.verifyHeaderSeal(block.header.view(), sealState);
     }
-    async transition(block, headerHash, omitSealVerification = false) {
+    async transition(block, headerHash, preverifiedSeal = null, omitSealVerification = false) {
         const headerView = block.header.view();
         const header = block.header.materialize();
         const timeSlot = header.timeSlotIndex;
         // safrole seal
-        let newEntropyHash;
+        let newEntropyHash = preverifiedSeal;
         if (omitSealVerification) {
             newEntropyHash = hashBytes(header.seal).asOpaque();
         }
-        else {
+        if (newEntropyHash === null) {
             const sealResult = await this.verifySeal(timeSlot, block);
             if (sealResult.isError) {
                 return stfError(StfErrorKind.SafroleSeal, sealResult);
@@ -63722,7 +64001,7 @@ class OnChain {
         assertEmpty(deferredTransfersRest);
         const accumulateRoot = await this.accumulateOutput.transition({ accumulationOutputLog });
         // recent history
-        const recentHistoryUpdate = this.recentHistory.transition({
+        const recentHistoryUpdate = await this.recentHistory.transition({
             partial: recentHistoryPartialUpdate,
             headerHash,
             accumulateRoot,
@@ -63802,7 +64081,6 @@ function checkOffendersMatch(offendersMark, headerOffendersMark) {
 
 
 
-
 var ImporterErrorKind;
 (function (ImporterErrorKind) {
     ImporterErrorKind[ImporterErrorKind["Verifier"] = 0] = "Verifier";
@@ -63830,28 +64108,29 @@ class Importer {
             throw new Error(`Unable to load best state from header hash: ${currentBestHeaderHash}.`);
         }
         this.verifier = new BlockVerifier(hasher, blocks);
-        this.stf = new OnChain(spec, state, blocks, hasher);
+        this.stf = new OnChain(spec, state, blocks, hasher, { enableParallelSealVerification: true });
         this.state = state;
         this.currentHash = currentBestHeaderHash;
         logger.info(`😎 Best time slot: ${state.timeslot} (header hash: ${currentBestHeaderHash})`);
     }
-    async importBlock(block, omitSealVerification) {
-        const timer = measure("importBlock");
-        const timeSlot = extractTimeSlot(block);
-        const maybeBestHeader = await this.importBlockInternal(block, omitSealVerification);
-        if (maybeBestHeader.isOk) {
-            const bestHeader = maybeBestHeader.ok;
-            this.logger.info(`🧊 Best block: #${timeSlot} (${bestHeader.hash})`);
-            this.logger.log(timer());
-            return maybeBestHeader;
-        }
-        this.logger.log(`❌ Rejected block #${timeSlot}: ${resultToString(maybeBestHeader)}`);
-        this.logger.log(timer());
-        return maybeBestHeader;
-    }
-    async importBlockInternal(block, omitSealVerification = false) {
+    /** Attempt to pre-verify the seal to speed up importing. */
+    async preverifySeal(timeSlot, block) {
+        try {
+            const res = await this.stf.verifySeal(timeSlot, block);
+            if (res.isOk) {
+                return res.ok;
+            }
+            this.logger.warn(`Unable to pre-verify the seal: ${resultToString(res)}`);
+            return null;
+        }
+        catch (e) {
+            this.logger.warn(`Error while trying to pre-verify the seal: ${e}`);
+            return null;
+        }
+    }
+    async importBlock(block, preverifiedSeal, omitSealVerification = false) {
         const logger = this.logger;
-        logger.log("🧱 Attempting to import a new block");
+        logger.log(`🧱 Attempting to import a new block ${preverifiedSeal !== null ? "(seal preverified)" : ""}`);
         const timerVerify = measure("import:verify");
         const hash = await this.verifier.verifyBlock(block);
         logger.log(timerVerify());
@@ -63876,7 +64155,7 @@ class Importer {
         const headerHash = hash.ok;
         logger.log(`🧱 Verified block: Got hash ${headerHash} for block at slot ${timeSlot}.`);
         const timerStf = measure("import:stf");
-        const res = await this.stf.transition(block, headerHash, omitSealVerification);
+        const res = await this.stf.transition(block, headerHash, preverifiedSeal, omitSealVerification);
         logger.log(timerStf());
         if (res.isError) {
             return importerError(ImporterErrorKind.Stf, res);
@@ -63926,19 +64205,6 @@ class Importer {
         return stateEntries ?? null;
     }
 }
-/**
- * Attempt to safely extract timeslot of a block.
- *
- * NOTE: it may fail if encoding is invalid.
- */
-function extractTimeSlot(block) {
-    try {
-        return block.header.view().timeSlotIndex.materialize();
-    }
-    catch {
-        return tryAsTimeSlot(2 ** 32 - 1);
-    }
-}
 
 ;// CONCATENATED MODULE: ./workers/importer/index.ts
 
@@ -63950,6 +64216,8 @@ function extractTimeSlot(block) {
 
 
 
+
+
 const importer_logger = Logger.new(import.meta.filename, "importer");
 if (!external_node_worker_threads_namespaceObject.isMainThread) {
     Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
@@ -63966,6 +64234,7 @@ async function createImporter(config) {
     const importer = new Importer(config.chainSpec, hasher, importer_logger, blocks, states);
     return {
         lmdb,
+        blocks,
         importer,
     };
 }
@@ -63980,27 +64249,65 @@ async function importer_main(channel) {
     importer_logger.info(`📥 Importer starting ${channel.currentState()}`);
     // Await the configuration object
     const ready = await channel.waitForState("ready(importer)");
-    let closeDb = async () => { };
     const finished = await ready.doUntil("finished", async (worker, port) => {
         const config = worker.getConfig();
-        const { lmdb, importer } = await createImporter(config);
-        closeDb = async () => {
-            await lmdb.close();
-        };
+        const { blocks, importer } = await createImporter(config);
         // TODO [ToDr] this is shit, since we have circular dependency.
         worker.setImporter(importer);
         importer_logger.info("📥 Importer waiting for blocks.");
+        // TODO [ToDr] back pressure?
+        let isProcessing = false;
+        const importingQueue = new ImportQueue(config.chainSpec, importer);
         worker.onBlock.on(async (block) => {
-            const res = await importer.importBlock(block, config.omitSealVerification);
-            if (res.isOk) {
-                worker.announce(port, res.ok);
+            const details = ImportQueue.getBlockDetails(block);
+            // ignore invalid blocks.
+            if (details.isError) {
+                importer_logger.trace("🧊 Ignoring invalid block.");
+                return;
+            }
+            // ignore already known blocks
+            if (blocks.getHeader(details.ok.hash) !== null) {
+                importer_logger.trace(`🧊 Already imported block: #${details.ok.data.timeSlot}.`);
+                return;
+            }
+            const importResult = importingQueue.push(details.ok);
+            // ignore blocks that are already queued
+            if (importResult.isError) {
+                importer_logger.trace(`🧊 Already queued block: #${details.ok.data.timeSlot}.`);
+                return;
+            }
+            importer_logger.log(`🧊 Queued block: #${details.ok.data.timeSlot} (skip seal: ${config.omitSealVerification})`);
+            if (isProcessing) {
+                return;
+            }
+            isProcessing = true;
+            try {
+                for (;;) {
+                    const entry = importingQueue.shift();
+                    if (entry === undefined) {
+                        return;
+                    }
+                    const { block, seal, timeSlot } = entry;
+                    const timer = measure("importBlock");
+                    const maybeBestHeader = await importer.importBlock(block, await seal, config.omitSealVerification);
+                    if (maybeBestHeader.isOk) {
+                        const bestHeader = maybeBestHeader.ok;
+                        worker.announce(port, bestHeader);
+                        importer_logger.info(`🧊 Best block: #${bestHeader.data.timeSlotIndex.materialize()} (${bestHeader.hash})`);
+                    }
+                    else {
+                        importer_logger.log(`❌ Rejected block #${timeSlot}: ${resultToString(maybeBestHeader)}`);
+                    }
+                    importer_logger.log(timer());
+                }
+            }
+            finally {
+                isProcessing = false;
             }
         });
         await wasmPromise;
     });
     importer_logger.info("📥 Importer finished. Closing channel.");
-    // close the database
-    await closeDb();
     // Close the comms to gracefuly close the app.
     finished.currentState().close(channel);
 }