@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/core/collections/sorted-set.js

@@ -0,0 +1,100 @@
+import { check } from "#@typeberry/utils";
+import { SortedArray } from "./sorted-array.js";
+/**
+ * Collection of elements of type `V` that has some strict ordering and does not have duplicates.
+ *
+ * The items are stored sorted, which allows logarithmic insertion & lookup
+ * and obviously in-order iteration.
+ *
+ * Duplicates are not allowed. Inserting an existing item is no-op.
+ */
+export class SortedSet extends SortedArray {
+    /**
+     * Create SortedSet from array that is not sorted. This function sorts the array.
+     * Duplicates are removed.
+     */
+    static fromArray(comparator, array = []) {
+        if (array.length === 0) {
+            return new SortedSet([], comparator);
+        }
+        const data = array.toSorted((a, b) => comparator(a, b).value);
+        const dataLength = data.length;
+        const nonDuplicates = [data[0]];
+        for (let i = 1; i < dataLength; i++) {
+            if (!comparator(data[i - 1], data[i]).isEqual()) {
+                nonDuplicates.push(data[i]);
+            }
+        }
+        return new SortedSet(nonDuplicates, comparator);
+    }
+    /**
+     * Create SortedSet from array that is not sorted. This function sorts the array.
+     * Duplicates are detected an are not allowed.
+     */
+    static fromArrayUnique(comparator, array) {
+        const data = array.toSorted((a, b) => comparator(a, b).value);
+        const dataLength = data.length;
+        for (let i = 1; i < dataLength; i++) {
+            if (comparator(data[i - 1], data[i]).isEqual()) {
+                throw new Error(`Expected array without duplicates, got: ${array}`);
+            }
+        }
+        return new SortedSet(data, comparator);
+    }
+    /**
+     * Create SortedSet from array that is sorted using given `comparator`.
+     *
+     * NOTE: This function does not sort the array. Unsorted array will throw an error.
+     */
+    static fromSortedArray(comparator, array = []) {
+        if (array.length === 0) {
+            return new SortedSet([], comparator);
+        }
+        const data = array.slice();
+        const dataLength = data.length;
+        for (let i = 1; i < dataLength; i++) {
+            if (comparator(data[i - 1], data[i]).isGreaterOrEqual()) {
+                throw new Error(`Expected sorted array without duplicates, got: ${data}`);
+            }
+        }
+        return new SortedSet(data, comparator);
+    }
+    /** Insert given element to the sorted set unless it's already there. */
+    insert(v) {
+        const findIdx = this.binarySearch(v);
+        if (!findIdx.isEqual) {
+            this.array.splice(findIdx.idx, 0, v);
+        }
+    }
+    /**
+     * Insert given element to the sorted set EVEN IF it's already present.
+     *
+     * Putting another value that's equal via comparator will replace the current one.
+     */
+    replace(v) {
+        const findIdx = this.binarySearch(v);
+        const toRemove = findIdx.isEqual ? 1 : 0;
+        this.array.splice(findIdx.idx, toRemove, v);
+    }
+    /** Create a new SortedSet from two sorted collections. */
+    static fromTwoSortedCollections(first, second) {
+        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);
+        }
+        if (second.length === 0) {
+            return SortedSet.fromSortedArray(comparator, first.array);
+        }
+        const mergedArray = SortedArray.fromTwoSortedCollections(first, second).array;
+        const mergedLength = mergedArray.length;
+        let j = 1;
+        for (let i = 1; i < mergedLength; i++) {
+            if (comparator(mergedArray[i - 1], mergedArray[i]).isNotEqual()) {
+                mergedArray[j++] = mergedArray[i];
+            }
+        }
+        mergedArray.length = j;
+        return SortedSet.fromSortedArray(comparator, mergedArray);
+    }
+}

package/packages/core/collections/sorted-set.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sorted-set.test.d.ts.map

package/packages/core/collections/sorted-set.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-set.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/collections/sorted-set.test.ts"],"names":[],"mappings":""}

package/packages/core/collections/sorted-set.test.js

@@ -0,0 +1,99 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Ordering } from "#@typeberry/ordering";
+import { SortedSet } from "./sorted-set.js";
+describe("SortedSet", () => {
+    const cmp = (self, other) => {
+        const r = self - other;
+        if (r > 0) {
+            return Ordering.Greater;
+        }
+        if (r < 0) {
+            return Ordering.Less;
+        }
+        return Ordering.Equal;
+    };
+    describe("fromArray / fromArrayNoDuplicates", () => {
+        it("should create SortedSet from not sorted array with duplicates", () => {
+            const data = [2, 1, 3, 2, 3, 1, 4, 4, 4, 4, 4];
+            const result = SortedSet.fromArray(cmp, data);
+            assert.deepStrictEqual(result.slice(), [1, 2, 3, 4]);
+        });
+        it("should create SortedSet from not sorted array", () => {
+            const data = [1, 3, 2];
+            const result = SortedSet.fromArrayUnique(cmp, data);
+            assert.deepStrictEqual(result.slice(), [1, 2, 3]);
+        });
+        it("should throw when using fromArray and array contains duplicates", () => {
+            const data = [1, 3, 3, 2];
+            const tryToCreate = () => SortedSet.fromArrayUnique(cmp, data);
+            assert.throws(tryToCreate, new Error(`Expected array without duplicates, got: ${data}`));
+        });
+    });
+    describe("fromSortedArray", () => {
+        it("should throw when using fromSortedArray and array is not sorted", () => {
+            const data = [1, 3, 2];
+            const tryToCreate = () => SortedSet.fromSortedArray(cmp, data);
+            assert.throws(tryToCreate, new Error(`Expected sorted array without duplicates, got: ${data}`));
+        });
+        it("should not throw when using fromSortedArray and array is sorted", () => {
+            const data = [1, 2, 3];
+            const result = SortedSet.fromSortedArray(cmp, data);
+            assert.deepStrictEqual(result.slice(), data);
+        });
+        it("should throw when using fromSortedArray and array is sorted and contains duplicates", () => {
+            const data = [1, 2, 2, 3];
+            const tryToCreate = () => SortedSet.fromSortedArray(cmp, data);
+            assert.throws(tryToCreate, new Error(`Expected sorted array without duplicates, got: ${data}`));
+        });
+    });
+    describe("insert", () => {
+        it("should insert a bunch of items and keep the in order", () => {
+            const data = SortedSet.fromArrayUnique(cmp, [5, 2, 3]);
+            data.insert(1);
+            data.insert(10);
+            data.insert(-50);
+            assert.deepStrictEqual(data.slice(), [-50, 1, 2, 3, 5, 10]);
+            assert.deepStrictEqual(data.length, 6);
+        });
+        it("should not insert duplicated items", () => {
+            const data = SortedSet.fromArrayUnique(cmp, [5, 2, 3]);
+            data.insert(5);
+            data.insert(5);
+            data.insert(3);
+            assert.deepStrictEqual(data.slice(), [2, 3, 5]);
+            assert.deepStrictEqual(data.length, 3);
+        });
+    });
+    describe("fromTwoSortedCollections", () => {
+        it("should merge two sorted sets without duplicates", () => {
+            const arr1 = [1, 2, 3];
+            const arr2 = [4, 5, 6];
+            const toMerge1 = SortedSet.fromArrayUnique(cmp, arr1);
+            const toMerge2 = SortedSet.fromArrayUnique(cmp, arr2);
+            const result = SortedSet.fromTwoSortedCollections(toMerge1, toMerge2);
+            assert.deepStrictEqual(result.slice(), [...arr1, ...arr2]);
+        });
+        it("should merge two sorted sets with duplicates", () => {
+            const arr = [1, 2, 3];
+            const toMerge1 = SortedSet.fromArrayUnique(cmp, arr);
+            const toMerge2 = SortedSet.fromArrayUnique(cmp, arr);
+            const result = SortedSet.fromTwoSortedCollections(toMerge1, toMerge2);
+            assert.deepStrictEqual(result.slice(), arr);
+        });
+        it("should merge two empty sets", () => {
+            const arr = [];
+            const toMerge1 = SortedSet.fromArrayUnique(cmp, arr);
+            const toMerge2 = SortedSet.fromArrayUnique(cmp, arr);
+            const result = SortedSet.fromTwoSortedCollections(toMerge1, toMerge2);
+            assert.deepStrictEqual(result.slice(), arr);
+        });
+        it("should merge two sets with one duplicated item", () => {
+            const arr = [0];
+            const toMerge1 = SortedSet.fromArrayUnique(cmp, arr);
+            const toMerge2 = SortedSet.fromArrayUnique(cmp, arr);
+            const result = SortedSet.fromTwoSortedCollections(toMerge1, toMerge2);
+            assert.deepStrictEqual(result.slice(), arr);
+        });
+    });
+});

package/packages/core/collections/truncated-hash-dictionary.d.ts

@@ -0,0 +1,35 @@
+import { type OpaqueHash, type TruncatedHash } from "#@typeberry/hash";
+import { TEST_COMPARE_USING } from "#@typeberry/utils";
+/**
+ * A collection of hash-based keys (likely `StateKey`s) which ignores
+ * differences on the last byte.
+ */
+export declare class TruncatedHashDictionary<T extends OpaqueHash, V> {
+    private readonly dict;
+    /**
+     * Create a new `TruncatedHashDictionary` from given list of entries.
+     *
+     * Each key will be copied and have the last byte replace with a 0.
+     */
+    static fromEntries<T extends OpaqueHash, V>(entries: Iterable<[T | TruncatedHash, V] | readonly [T | TruncatedHash, V]>): TruncatedHashDictionary<T, V>;
+    private constructor();
+    [TEST_COMPARE_USING](): [TruncatedHash, V][];
+    /** Return number of items in the dictionary. */
+    get size(): number;
+    /** Retrieve a value that matches the key on `TRUNCATED_HASH_SIZE`. */
+    get(key: T | TruncatedHash): V | undefined;
+    /** Return true if the key is present in the dictionary */
+    has(key: T | TruncatedHash): boolean;
+    /** Set or update a value that matches the key on `TRUNCATED_HASH_SIZE`. */
+    set(key: T | TruncatedHash, value: V): void;
+    /** Remove a value that matches the key on `TRUNCATED_HASH_SIZE`. */
+    delete(key: T | TruncatedHash): void;
+    /** Iterator over keys of the dictionary. */
+    keys(): Iterator<TruncatedHash, any, any> & Iterable<TruncatedHash>;
+    /** Iterator over values of the dictionary. */
+    values(): Iterator<V, any, any> & Iterable<V>;
+    /** Iterator over entries of the dictionary (with truncated keys) */
+    entries(): Generator<[TruncatedHash, V]>;
+    [Symbol.iterator](): Generator<[TruncatedHash, V], any, any>;
+}
+//# sourceMappingURL=truncated-hash-dictionary.d.ts.map

package/packages/core/collections/truncated-hash-dictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncated-hash-dictionary.d.ts","sourceRoot":"","sources":["../../../../../packages/core/collections/truncated-hash-dictionary.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAuB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3F,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAkBtD;;;GAGG;AACH,qBAAa,uBAAuB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC;IAiBtC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAhBzC;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,EACxC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,aAAa,EAAE,CAAC,CAAC,CAAC,GAC1E,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC;IAShC,OAAO;IAEP,CAAC,kBAAkB,CAAC;IAIpB,gDAAgD;IAChD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,sEAAsE;IACtE,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,aAAa,GAAG,CAAC,GAAG,SAAS;IAK1C,0DAA0D;IAC1D,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,aAAa,GAAG,OAAO;IAKpC,2EAA2E;IAC3E,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,aAAa,EAAE,KAAK,EAAE,CAAC;IAKpC,oEAAoE;IACpE,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,aAAa;IAK7B,4CAA4C;IAC5C,IAAI;IAIJ,8CAA8C;IAC9C,MAAM;IAIN,oEAAoE;IACnE,OAAO,IAAI,SAAS,CAAC,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;IAIzC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAGlB"}

package/packages/core/collections/truncated-hash-dictionary.js

@@ -0,0 +1,76 @@
+import { Bytes } from "#@typeberry/bytes";
+import { TRUNCATED_HASH_SIZE } from "#@typeberry/hash";
+import { TEST_COMPARE_USING } from "#@typeberry/utils";
+import { BlobDictionary } from "./blob-dictionary.js";
+function getTruncatedKey(key) {
+    // Always return exactly TRUNCATED_HASH_SIZE bytes.
+    if (key.length === TRUNCATED_HASH_SIZE) {
+        return key;
+    }
+    return Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+}
+/**
+ * A value that indicates when `BlobDictionary` transforms Array nodes into Map nodes.
+ * In practice, it doesn't matter much because, in real life, arrays in this structure usually have a length close to 1.
+ */
+const BLOB_DICTIONARY_THRESHOLD = 5;
+/**
+ * A collection of hash-based keys (likely `StateKey`s) which ignores
+ * differences on the last byte.
+ */
+export class TruncatedHashDictionary {
+    dict;
+    /**
+     * Create a new `TruncatedHashDictionary` from given list of entries.
+     *
+     * Each key will be copied and have the last byte replace with a 0.
+     */
+    static fromEntries(entries) {
+        return new TruncatedHashDictionary(BlobDictionary.fromEntries(Array.from(entries).map(([key, value]) => [getTruncatedKey(key), value]), BLOB_DICTIONARY_THRESHOLD));
+    }
+    constructor(dict) {
+        this.dict = dict;
+    }
+    [TEST_COMPARE_USING]() {
+        return Array.from(this.dict);
+    }
+    /** Return number of items in the dictionary. */
+    get size() {
+        return this.dict.size;
+    }
+    /** Retrieve a value that matches the key on `TRUNCATED_HASH_SIZE`. */
+    get(key) {
+        const truncatedKey = getTruncatedKey(key);
+        return this.dict.get(truncatedKey);
+    }
+    /** Return true if the key is present in the dictionary */
+    has(key) {
+        const truncatedKey = getTruncatedKey(key);
+        return this.dict.has(truncatedKey);
+    }
+    /** Set or update a value that matches the key on `TRUNCATED_HASH_SIZE`. */
+    set(key, value) {
+        const truncatedKey = getTruncatedKey(key);
+        this.dict.set(truncatedKey, value);
+    }
+    /** Remove a value that matches the key on `TRUNCATED_HASH_SIZE`. */
+    delete(key) {
+        const truncatedKey = getTruncatedKey(key);
+        this.dict.delete(truncatedKey);
+    }
+    /** Iterator over keys of the dictionary. */
+    keys() {
+        return this.dict.keys();
+    }
+    /** Iterator over values of the dictionary. */
+    values() {
+        return this.dict.values();
+    }
+    /** Iterator over entries of the dictionary (with truncated keys) */
+    *entries() {
+        yield* this.dict.entries();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}

package/packages/core/collections/truncated-hash-dictionary.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=truncated-hash-dictionary.test.d.ts.map

package/packages/core/collections/truncated-hash-dictionary.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncated-hash-dictionary.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/collections/truncated-hash-dictionary.test.ts"],"names":[],"mappings":""}

package/packages/core/collections/truncated-hash-dictionary.test.js

@@ -0,0 +1,178 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE, TRUNCATED_HASH_SIZE } from "#@typeberry/hash";
+import { TruncatedHashDictionary } from "./truncated-hash-dictionary.js";
+describe("TruncatedHashDictionary", () => {
+    describe("get", () => {
+        it("should return undefined when dictionary is empty", () => {
+            const queryKey = Bytes.parseBytes("0x1111111111111111111111111111111111111111111111111111111111111122", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([]);
+            // when
+            const res = dict.get(queryKey);
+            // then
+            assert.deepStrictEqual(res, undefined);
+        });
+        it("should retrieve the value if key differs at last byte", () => {
+            const key1 = Bytes.parseBytes("0x11111111111111111111111111111111111111111111111111111111111111aa", HASH_SIZE);
+            const key2 = Bytes.parseBytes("0x11111111111111111111111111111111111111111111111111111111111111ff", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([
+                [key1, "abc"],
+                [Bytes.fill(HASH_SIZE, 2), "def"],
+            ]);
+            // when
+            const res1 = dict.get(key1);
+            const res2 = dict.get(key2);
+            // then
+            assert.deepStrictEqual(res1, "abc");
+            assert.deepStrictEqual(res1, res2);
+        });
+        it("should return the value from the last entry if truncated keys collide", () => {
+            const key1 = Bytes.parseBytes("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa01", HASH_SIZE);
+            const key2 = Bytes.parseBytes("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaff", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([
+                [key1, "first"],
+                [key2, "second"], // same prefix, should override
+            ]);
+            // when
+            const res = dict.get(key1);
+            // then
+            assert.deepStrictEqual(res, "second");
+        });
+        it("should retrieve the value when using a truncated key for lookup", () => {
+            const fullKey = Bytes.parseBytes("0xababababababababababababababababababababababababababababababab00", HASH_SIZE);
+            const truncatedKey = Bytes.fromBlob(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([[fullKey, "value"]]);
+            // when
+            const res = dict.get(truncatedKey);
+            // then
+            assert.deepStrictEqual(res, "value");
+        });
+        it("should return undefined for a key with a different truncated prefix", () => {
+            const insertedKey = Bytes.parseBytes("0x99999999999999999999999999999999999999999999999999999999999999ff", HASH_SIZE);
+            const queryKey = Bytes.parseBytes("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaff", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([[insertedKey, "exists"]]);
+            // when
+            const res = dict.get(queryKey);
+            // then
+            assert.deepStrictEqual(res, undefined);
+        });
+        it("should not mutate original keys during fromEntries", () => {
+            const original = Bytes.parseBytes("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaff", HASH_SIZE);
+            const copyBefore = original.raw.slice(); // snapshot
+            const dict = TruncatedHashDictionary.fromEntries([[original, "value"]]);
+            // when
+            dict.get(original); // access to possibly trigger mutation
+            // then
+            assert.deepStrictEqual(original.raw, copyBefore); // unchanged
+        });
+    });
+    describe("set", () => {
+        it("should set a new key-value pair", () => {
+            const key = Bytes.parseBytes("0x1111111111111111111111111111111111111111111111111111111111111111", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([]);
+            // when
+            dict.set(key, "new value");
+            // then
+            assert.deepStrictEqual(dict.get(key), "new value");
+        });
+        it("should update an existing key", () => {
+            const key = Bytes.parseBytes("0x2222222222222222222222222222222222222222222222222222222222222222", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([[key, "original"]]);
+            // when
+            dict.set(key, "updated");
+            // then
+            assert.deepStrictEqual(dict.get(key), "updated");
+        });
+        it("should set with truncated keys", () => {
+            const fullKey = Bytes.parseBytes("0x3333333333333333333333333333333333333333333333333333333333333333", HASH_SIZE);
+            const truncatedKey = Bytes.fromBlob(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([]);
+            // when
+            dict.set(truncatedKey, "truncated value");
+            // then
+            assert.deepStrictEqual(dict.get(fullKey), "truncated value");
+            assert.deepStrictEqual(dict.get(truncatedKey), "truncated value");
+        });
+        it("should overwrite when setting keys with same truncated prefix", () => {
+            const key1 = Bytes.parseBytes("0x4444444444444444444444444444444444444444444444444444444444444401", HASH_SIZE);
+            const key2 = Bytes.parseBytes("0x44444444444444444444444444444444444444444444444444444444444444ff", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([[key1, "first"]]);
+            // when
+            dict.set(key2, "second");
+            // then
+            assert.deepStrictEqual(dict.get(key1), "second");
+            assert.deepStrictEqual(dict.get(key2), "second");
+        });
+        it("should not reuse the same key object reference for different entries", () => {
+            const key1 = Bytes.parseBytes("0x4444444444444444444444444444444444444444444444444444444444444444", HASH_SIZE);
+            const key2 = Bytes.parseBytes("0x5555555555555555555555555555555555555555555555555555555555555555", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([]);
+            dict.set(key1, "first");
+            dict.set(key2, "second");
+            const keys = [];
+            for (const [key, _] of dict) {
+                keys.push(key);
+            }
+            assert.strictEqual([...new Set(keys)].length, 2);
+        });
+    });
+    describe("delete", () => {
+        it("should delete an existing key", () => {
+            const key = Bytes.parseBytes("0x5555555555555555555555555555555555555555555555555555555555555555", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([[key, "to delete"]]);
+            // when
+            dict.delete(key);
+            // then
+            assert.deepStrictEqual(dict.get(key), undefined);
+        });
+        it("should handle deleting a non-existent key", () => {
+            const key = Bytes.parseBytes("0x6666666666666666666666666666666666666666666666666666666666666666", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([]);
+            // when
+            dict.delete(key);
+            // then
+            assert.deepStrictEqual(dict.get(key), undefined);
+        });
+        it("should delete with truncated keys", () => {
+            const fullKey = Bytes.parseBytes("0x7777777777777777777777777777777777777777777777777777777777777777", HASH_SIZE);
+            const truncatedKey = Bytes.fromBlob(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([[fullKey, "to delete"]]);
+            // when
+            dict.delete(truncatedKey);
+            // then
+            assert.deepStrictEqual(dict.get(fullKey), undefined);
+            assert.deepStrictEqual(dict.get(truncatedKey), undefined);
+        });
+        it("should delete when keys have same truncated prefix", () => {
+            const key1 = Bytes.parseBytes("0x8888888888888888888888888888888888888888888888888888888888888801", HASH_SIZE);
+            const key2 = Bytes.parseBytes("0x88888888888888888888888888888888888888888888888888888888888888ff", HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([[key1, "value"]]);
+            // when
+            dict.delete(key2);
+            // then
+            assert.deepStrictEqual(dict.get(key1), undefined);
+            assert.deepStrictEqual(dict.get(key2), undefined);
+        });
+    });
+    describe("entries", () => {
+        it("should return entries with truncated keys", () => {
+            const key1 = Bytes.parseBytes("0x8888888888888888888888888888888888888888888888888888888888888801", HASH_SIZE);
+            const key2 = Bytes.parseBytes("0x88888888888888888888888888888888888888888888888888888888888888ff", HASH_SIZE);
+            const truncatedKey12 = Bytes.parseBytes("0x88888888888888888888888888888888888888888888888888888888888888", TRUNCATED_HASH_SIZE);
+            const key3 = Bytes.parseBytes("0x77777777777777777777777777777777777777777777777777777777777777ff", HASH_SIZE);
+            const truncatedKey3 = Bytes.parseBytes("0x77777777777777777777777777777777777777777777777777777777777777", TRUNCATED_HASH_SIZE);
+            const dict = TruncatedHashDictionary.fromEntries([
+                [key1, "value"],
+                [key2, "value2"],
+                [key3, "value3"],
+            ]);
+            const entries = Array.from(dict.entries());
+            assert.deepStrictEqual(entries.length, 2);
+            assert.deepStrictEqual(entries[0][0].toString(), truncatedKey12.toString());
+            assert.deepStrictEqual(entries[0][1], "value2");
+            assert.deepStrictEqual(entries[1][0].toString(), truncatedKey3.toString());
+            assert.deepStrictEqual(entries[1][1], "value3");
+        });
+    });
+});

package/packages/core/concurrent/index.d.ts

@@ -0,0 +1,4 @@
+export type { IExecutor } from "./messages.js";
+export * from "./parent.js";
+export * from "./worker.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/core/concurrent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/concurrent/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/packages/core/concurrent/index.js

@@ -0,0 +1,2 @@
+export * from "./parent.js";
+export * from "./worker.js";

package/packages/core/concurrent/messages.d.ts

@@ -0,0 +1,16 @@
+import type { Transferable } from "node:worker_threads";
+import type { Result } from "#@typeberry/utils";
+export interface IExecutor<TParams, TResult> {
+    run(params: TParams): Promise<TResult>;
+    destroy(): Promise<void>;
+}
+export type WithTransferList = {
+    getTransferList(): Transferable[];
+};
+/** Message going from parent thread to worker thread. */
+export type MessageIn<TParams> = {
+    params: TParams;
+};
+/** Response from worker to the parent. */
+export type MessageOut<TResult> = Result<TResult, string>;
+//# sourceMappingURL=messages.d.ts.map

package/packages/core/concurrent/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../../packages/core/concurrent/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,WAAW,SAAS,CAAC,OAAO,EAAE,OAAO;IACzC,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,eAAe,IAAI,YAAY,EAAE,CAAC;CACnC,CAAC;AAEF,yDAAyD;AACzD,MAAM,MAAM,SAAS,CAAC,OAAO,IAAI;IAC/B,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,0CAA0C;AAC1C,MAAM,MAAM,UAAU,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC"}

package/packages/core/concurrent/messages.js

@@ -0,0 +1 @@
+export {};

package/packages/core/concurrent/parent.d.ts

@@ -0,0 +1,35 @@
+import type { IExecutor, WithTransferList } from "./messages.js";
+/** Executor options. */
+export type ExecutorOptions = {
+    /** Minimal and initial number of workers, initialized before start. */
+    minWorkers: number;
+    /**
+     * Maximal number of workers that can be created in total.
+     *
+     * Workers between `(minWorkers, maxWorkers]` are created on demand,
+     * when there is too many tasks pending in the queue.
+     */
+    maxWorkers: number;
+};
+/** Execution pool manager. */
+export declare class Executor<TParams extends WithTransferList, TResult> implements IExecutor<TParams, TResult> {
+    private readonly workers;
+    private readonly maxWorkers;
+    private readonly workerPath;
+    /** Initialize a new concurrent executor given a path to the worker. */
+    static initialize<XParams extends WithTransferList, XResult extends WithTransferList>(workerPath: URL, options: ExecutorOptions): Promise<Executor<XParams, XResult>>;
+    private readonly freeWorkerIndices;
+    private readonly taskQueue;
+    private isDestroyed;
+    private isWorkerInitializing;
+    private constructor();
+    /** Attempt to initialize a new worker. */
+    initNewWorker(onSuccess?: () => void): Promise<void>;
+    /** Terminate all workers and clear the executor. */
+    destroy(): Promise<void>;
+    /** Execute a task with given parameters. */
+    run(params: TParams): Promise<TResult>;
+    /** Process single element from the task queue. */
+    private processEntryFromTaskQueue;
+}
+//# sourceMappingURL=parent.d.ts.map

package/packages/core/concurrent/parent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent.d.ts","sourceRoot":"","sources":["../../../../../packages/core/concurrent/parent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAyB,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMxF,wBAAwB;AACxB,MAAM,MAAM,eAAe,GAAG;IAC5B,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,8BAA8B;AAC9B,qBAAa,QAAQ,CAAC,OAAO,SAAS,gBAAgB,EAAE,OAAO,CAAE,YAAW,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;IAsBnG,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAvB7B,uEAAuE;WAC1D,UAAU,CAAC,OAAO,SAAS,gBAAgB,EAAE,OAAO,SAAS,gBAAgB,EACxF,UAAU,EAAE,GAAG,EACf,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAWtC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAgB;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAC1D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,oBAAoB,CAAS;IAErC,OAAO;IAWP,0CAA0C;IACpC,aAAa,CAAC,SAAS,GAAE,MAAM,IAAe;IAiBpD,oDAAoD;IAC9C,OAAO;IASb,4CAA4C;IACtC,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAgB5C,kDAAkD;IAClD,OAAO,CAAC,yBAAyB;CA6BlC"}