@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/core/collections/blob-dictionary.test.js

@@ -0,0 +1,162 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { BlobDictionary, bytesAsU48 } from "./blob-dictionary.js";
+const TRESHOLDS = [0, 5, 10];
+describe("Blob dictionary", () => {
+    describe("bytesAsU48", () => {
+        it("should convert bytes to u48", () => {
+            const bytes = BytesBlob.parseBlob("0x112233445566").raw;
+            const expectedResult = 0x112233445566 * 8 + 6;
+            const result = bytesAsU48(bytes);
+            assert.strictEqual(result, expectedResult);
+        });
+        it("should convert empty bytes to 0", () => {
+            const bytes = BytesBlob.parseBlob("0x").raw;
+            const expectedResult = 0;
+            const result = bytesAsU48(bytes);
+            assert.strictEqual(result, expectedResult);
+        });
+        it("should distuingigh shorted chunk and padded with 0s", () => {
+            const bytes1 = BytesBlob.parseBlob("0x1122").raw;
+            const bytes2 = BytesBlob.parseBlob("0x112200").raw;
+            const result1 = bytesAsU48(bytes1);
+            const result2 = bytesAsU48(bytes2);
+            assert.notStrictEqual(result1, result2);
+        });
+    });
+    describe("public API", () => {
+        for (const threshold of TRESHOLDS) {
+            describe(`BlobDictionary(${threshold})`, () => {
+                it("should add item to BlobDictionary and then return it", () => {
+                    const key = BytesBlob.parseBlob("0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef");
+                    const val = { a: 1 };
+                    const dict = BlobDictionary.new(threshold);
+                    assert.strictEqual(dict.has(key), false);
+                    dict.set(key, val);
+                    assert.strictEqual(dict.has(key), true);
+                    const result = dict.get(key);
+                    assert.deepStrictEqual(result, val);
+                });
+                it("should override existing item", () => {
+                    const key = BytesBlob.parseBlob("0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef");
+                    const val1 = { a: 1 };
+                    const val2 = { a: 2 };
+                    const dict = BlobDictionary.new(threshold);
+                    assert.strictEqual(dict.has(key), false);
+                    dict.set(key, val1);
+                    dict.set(key, val2);
+                    const result = dict.get(key);
+                    assert.deepStrictEqual(result, val2);
+                });
+                it("should add item to BlobDictionary and then remove it", () => {
+                    const key = BytesBlob.parseBlob("0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef");
+                    const val = { a: 1 };
+                    const dict = BlobDictionary.new(threshold);
+                    assert.strictEqual(dict.has(key), false);
+                    dict.set(key, val);
+                    assert.strictEqual(dict.has(key), true);
+                    dict.delete(key);
+                    assert.strictEqual(dict.has(key), false);
+                });
+                it("should add empty blob as key", () => {
+                    const key = BytesBlob.empty();
+                    const val = { a: 1 };
+                    const dict = BlobDictionary.new(threshold);
+                    assert.strictEqual(dict.has(key), false);
+                    dict.set(key, val);
+                    assert.strictEqual(dict.has(key), true);
+                    const result = dict.get(key);
+                    assert.deepStrictEqual(result, val);
+                });
+                it("should store a few items with the same prefix and then remove all of them", () => {
+                    const entries = [
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef1"), { index: 1 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef2"), { index: 2 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef3"), { index: 3 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef4"), { index: 4 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef5"), { index: 5 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef6"), { index: 6 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef7"), { index: 7 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef8"), { index: 8 }],
+                        [BytesBlob.parseBlob("0x112233445566778899aabbccddeef9"), { index: 9 }],
+                    ];
+                    const dict = BlobDictionary.new(threshold);
+                    for (const [key, val] of entries) {
+                        dict.set(key, val);
+                    }
+                    for (const [key, val] of entries) {
+                        const result = dict.get(key);
+                        assert.deepStrictEqual(val, result);
+                    }
+                    for (const [key] of entries) {
+                        dict.delete(key);
+                    }
+                    for (const [key] of entries) {
+                        assert.strictEqual(dict.has(key), false);
+                    }
+                });
+                function key(n) {
+                    return Bytes.fill(HASH_SIZE, n);
+                }
+                it("should return true/false for keys present in the dictionary", () => {
+                    const dict = BlobDictionary.new(threshold);
+                    dict.set(key(1), "Hello World!");
+                    dict.set(key(2), "Hello!");
+                    assert.deepStrictEqual(dict.has(key(0)), false);
+                    assert.deepStrictEqual(dict.has(key(1)), true);
+                    assert.deepStrictEqual(dict.has(key(2)), true);
+                    assert.deepStrictEqual(dict.has(key(3)), false);
+                });
+                it("should set and get some values", () => {
+                    const dict = BlobDictionary.new(threshold);
+                    dict.set(key(1), "Hello World!");
+                    dict.set(key(2), "Hello!");
+                    assert.deepStrictEqual(dict.get(key(0)), undefined);
+                    assert.deepStrictEqual(dict.get(key(1)), "Hello World!");
+                    assert.deepStrictEqual(dict.get(key(2)), "Hello!");
+                    assert.deepStrictEqual(dict.get(key(4)), undefined);
+                });
+                it("should remove some values", () => {
+                    const dict = BlobDictionary.new(threshold);
+                    dict.set(key(1), "Hello World!");
+                    dict.set(key(2), "Hello!");
+                    assert.deepStrictEqual(dict.has(key(1)), true);
+                    assert.deepStrictEqual(dict.has(key(2)), true);
+                    dict.delete(key(0));
+                    dict.delete(key(1));
+                    dict.delete(key(3));
+                    assert.deepStrictEqual(dict.has(key(0)), false);
+                    assert.deepStrictEqual(dict.has(key(1)), false);
+                    assert.deepStrictEqual(dict.has(key(2)), true);
+                    assert.deepStrictEqual(dict.has(key(3)), false);
+                });
+                it("should iterate over values", () => {
+                    const dict = BlobDictionary.new(threshold);
+                    dict.set(key(1), "Hello World!");
+                    dict.set(key(2), "Hello!");
+                    const values = Array.from(dict.values());
+                    assert.deepStrictEqual(values, ["Hello World!", "Hello!"]);
+                });
+                it("should iterate over keys", () => {
+                    const dict = BlobDictionary.new(threshold);
+                    dict.set(key(1), "Hello World!");
+                    dict.set(key(2), "Hello!");
+                    const keys = Array.from(dict.keys());
+                    assert.deepStrictEqual(keys, [key(1), key(2)]);
+                });
+                it("should iterate over entries", () => {
+                    const dict = BlobDictionary.new(threshold);
+                    dict.set(key(1), "Hello World!");
+                    dict.set(key(2), "Hello!");
+                    const values = Array.from(dict);
+                    assert.deepStrictEqual(values, [
+                        [key(1), "Hello World!"],
+                        [key(2), "Hello!"],
+                    ]);
+                });
+            });
+        }
+    });
+});

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

@@ -0,0 +1,53 @@
+import type { OpaqueHash } from "#@typeberry/hash";
+import type { Comparator } from "#@typeberry/ordering";
+/** Immutable view of the `HashDictionary`. */
+export interface ImmutableHashDictionary<K extends OpaqueHash, V> extends Iterable<[K, V]> {
+    /** Return number of items in the dictionary. */
+    get size(): number;
+    /** Return true if the key is present in the dictionary. */
+    has(key: K): boolean;
+    /** Get the value under given key or `undefined` if the value is not present. */
+    get(key: K): V | undefined;
+    /** Iterator over keys of the dictionary. */
+    keys(): Iterator<K>;
+    /** Iterator over values of the dictionary. */
+    values(): Iterator<V>;
+    /** Returns an array of the map's values, sorted by their corresponding keys */
+    toSortedArray(compare: Comparator<K>): V[];
+}
+/**
+ * A map which uses hashes as keys.
+ *
+ * @deprecated
+ * */
+export declare class StringHashDictionary<K extends OpaqueHash, V> implements ImmutableHashDictionary<K, V> {
+    private readonly map;
+    private constructor();
+    /** Create a new, empty hash dictionary. */
+    static new<K extends OpaqueHash, V>(): HashDictionary<K, V>;
+    /** Create a new hash dictionary from given entires array. */
+    static fromEntries<K extends OpaqueHash, V>(entries: [K, V][]): HashDictionary<K, V>;
+    get size(): number;
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    /** it allows to use HashDictionary in for-of loop */
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    entries(): MapIterator<[K, V]>;
+    keys(): Generator<K, void, unknown>;
+    values(): Generator<V, void, unknown>;
+    toSortedArray(compare: Comparator<K>): V[];
+    toJSON(): any;
+    /** Insert/overwrite the value at given key. */
+    set(key: K, value: V): void;
+    /**
+     * Remove the key and any value from the dictionary.
+     *
+     * Returns `true` if element existed and was removed, `false` otherwise.
+     */
+    delete(key: K): boolean;
+}
+import { BlobDictionary } from "./blob-dictionary.js";
+export declare class HashDictionary<K extends OpaqueHash, V> extends BlobDictionary<K, V> implements ImmutableHashDictionary<K, V> {
+    constructor();
+}
+//# sourceMappingURL=hash-dictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash-dictionary.d.ts","sourceRoot":"","sources":["../../../../../packages/core/collections/hash-dictionary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,8CAA8C;AAC9C,MAAM,WAAW,uBAAuB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACxF,gDAAgD;IAChD,IAAI,IAAI,IAAI,MAAM,CAAC;IACnB,2DAA2D;IAC3D,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IACrB,gFAAgF;IAChF,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE3B,4CAA4C;IAC5C,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC;IAEpB,8CAA8C;IAC9C,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC;IAEtB,+EAA+E;IAC/E,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;CAC5C;AACD;;;;KAIK;AACL,qBAAa,oBAAoB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,CAAE,YAAW,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC;IAIjG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA6B;IAEjD,OAAO;IAEP,2CAA2C;IAC3C,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC;IAIlC,6DAA6D;IAC7D,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC;IAQpF,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAI1B,qDAAqD;IACrD,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIjB,OAAO;IAIN,IAAI;IAMJ,MAAM;IAMP,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;IAM1C,MAAM;IAIN,+CAA+C;IAC/C,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC;IAIpB;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC;CAGd;AAED,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAOtD,qBAAa,cAAc,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,CACjD,SAAQ,cAAc,CAAC,CAAC,EAAE,CAAC,CAC3B,YAAW,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC;;CAKzC"}

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

@@ -0,0 +1,81 @@
+/**
+ * A map which uses hashes as keys.
+ *
+ * @deprecated
+ * */
+export class StringHashDictionary {
+    // TODO [ToDr] [crit] We can't use `TrieHash` directly in the map,
+    // because of the way it's being compared. Hence having `string` here.
+    // This has to be benchmarked and re-written to a custom map most likely.
+    map = new Map();
+    constructor() { }
+    /** Create a new, empty hash dictionary. */
+    static new() {
+        return new HashDictionary();
+    }
+    /** Create a new hash dictionary from given entires array. */
+    static fromEntries(entries) {
+        const dict = new HashDictionary();
+        for (const [key, value] of entries) {
+            dict.set(key, value);
+        }
+        return dict;
+    }
+    get size() {
+        return this.map.size;
+    }
+    has(key) {
+        return this.map.has(key.toString());
+    }
+    get(key) {
+        return this.map.get(key.toString())?.[1];
+    }
+    /** it allows to use HashDictionary in for-of loop */
+    [Symbol.iterator]() {
+        return this.map.values();
+    }
+    entries() {
+        return this.map.values();
+    }
+    *keys() {
+        for (const value of this.map.values()) {
+            yield value[0];
+        }
+    }
+    *values() {
+        for (const value of this.map.values()) {
+            yield value[1];
+        }
+    }
+    toSortedArray(compare) {
+        const vals = Array.from(this.map.values());
+        vals.sort((a, b) => compare(a[0], b[0]).value);
+        return vals.map((x) => x[1]);
+    }
+    toJSON() {
+        return Object.fromEntries(this);
+    }
+    /** Insert/overwrite the value at given key. */
+    set(key, value) {
+        this.map.set(key.toString(), [key, value]);
+    }
+    /**
+     * Remove the key and any value from the dictionary.
+     *
+     * Returns `true` if element existed and was removed, `false` otherwise.
+     */
+    delete(key) {
+        return this.map.delete(key.toString());
+    }
+}
+import { BlobDictionary } from "./blob-dictionary.js";
+/**
+ * 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;
+export class HashDictionary extends BlobDictionary {
+    constructor() {
+        super(BLOB_DICTIONARY_THRESHOLD);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,66 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { HashDictionary } from "./hash-dictionary.js";
+function key(n) {
+    return Bytes.fill(HASH_SIZE, n);
+}
+describe("HashDictionary", () => {
+    it("should return true/false for keys present in the dictionary", () => {
+        const dict = HashDictionary.new();
+        dict.set(key(1), "Hello World!");
+        dict.set(key(2), "Hello!");
+        assert.deepStrictEqual(dict.has(key(0)), false);
+        assert.deepStrictEqual(dict.has(key(1)), true);
+        assert.deepStrictEqual(dict.has(key(2)), true);
+        assert.deepStrictEqual(dict.has(key(3)), false);
+    });
+    it("should set and get some values", () => {
+        const dict = HashDictionary.new();
+        dict.set(key(1), "Hello World!");
+        dict.set(key(2), "Hello!");
+        assert.deepStrictEqual(dict.get(key(0)), undefined);
+        assert.deepStrictEqual(dict.get(key(1)), "Hello World!");
+        assert.deepStrictEqual(dict.get(key(2)), "Hello!");
+        assert.deepStrictEqual(dict.get(key(4)), undefined);
+    });
+    it("should remove some values", () => {
+        const dict = HashDictionary.new();
+        dict.set(key(1), "Hello World!");
+        dict.set(key(2), "Hello!");
+        assert.deepStrictEqual(dict.has(key(1)), true);
+        assert.deepStrictEqual(dict.has(key(2)), true);
+        dict.delete(key(0));
+        dict.delete(key(1));
+        dict.delete(key(3));
+        assert.deepStrictEqual(dict.has(key(0)), false);
+        assert.deepStrictEqual(dict.has(key(1)), false);
+        assert.deepStrictEqual(dict.has(key(2)), true);
+        assert.deepStrictEqual(dict.has(key(3)), false);
+    });
+    it("should iterate over values", () => {
+        const dict = HashDictionary.new();
+        dict.set(key(1), "Hello World!");
+        dict.set(key(2), "Hello!");
+        const values = Array.from(dict.values());
+        assert.deepStrictEqual(values, ["Hello World!", "Hello!"]);
+    });
+    it("should iterate over keys", () => {
+        const dict = HashDictionary.new();
+        dict.set(key(1), "Hello World!");
+        dict.set(key(2), "Hello!");
+        const keys = Array.from(dict.keys());
+        assert.deepStrictEqual(keys, [key(1), key(2)]);
+    });
+    it("should iterate over entries", () => {
+        const dict = HashDictionary.new();
+        dict.set(key(1), "Hello World!");
+        dict.set(key(2), "Hello!");
+        const values = Array.from(dict);
+        assert.deepStrictEqual(values, [
+            [key(1), "Hello World!"],
+            [key(2), "Hello!"],
+        ]);
+    });
+});

package/packages/core/collections/hash-set.d.ts

@@ -0,0 +1,41 @@
+import type { OpaqueHash } from "#@typeberry/hash";
+import { HashDictionary } from "./hash-dictionary.js";
+/** Immutable version of the HashSet. */
+export interface ImmutableHashSet<V extends OpaqueHash> extends Iterable<V> {
+    /** Return number of items in the set. */
+    get size(): number;
+    /** Check if given hash is in the set. */
+    has(value: V): boolean;
+    /**
+     * Return an iterator over elements that are in the intersection of both sets.
+     * i.e. they exist in both.
+     */
+    intersection(other: ImmutableHashSet<V>): Generator<V>;
+}
+/** A set specialized for storing hashes. */
+export declare class HashSet<V extends OpaqueHash> implements ImmutableHashSet<V> {
+    private readonly map;
+    /** Wrap given dictionary into `HashSet` api for it's keys. */
+    static viewDictionaryKeys<V extends OpaqueHash>(dict: HashDictionary<V, unknown>): HashSet<V>;
+    /** Create new set from given array of values. */
+    static from<V extends OpaqueHash>(values: readonly V[]): HashSet<V>;
+    /** Create an empty set of hashes. */
+    static new<V extends OpaqueHash>(): HashSet<V>;
+    private constructor();
+    get size(): number;
+    has(value: V): boolean;
+    intersection(other: ImmutableHashSet<V>): Generator<V>;
+    /** it allows to use HashSet in for-of loop */
+    [Symbol.iterator](): Generator<V, void, unknown>;
+    /** Insert given hash to the set. */
+    insert(value: V): void;
+    /** Insert multiple items to the set. */
+    insertAll(values: readonly V[]): void;
+    /**
+     * Remove value from set.
+     *
+     * Returns `true` if element existed in the set and was removed, `false` otherwise.
+     */
+    delete(value: V): boolean;
+}
+//# sourceMappingURL=hash-set.d.ts.map

package/packages/core/collections/hash-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-set.d.ts","sourceRoot":"","sources":["../../../../../packages/core/collections/hash-set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,wCAAwC;AACxC,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IACzE,yCAAyC;IACzC,IAAI,IAAI,IAAI,MAAM,CAAC;IAEnB,yCAAyC;IACzC,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAEvB;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;CACxD;AAED,4CAA4C;AAC5C,qBAAa,OAAO,CAAC,CAAC,SAAS,UAAU,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;IAkBnD,OAAO,CAAC,QAAQ,CAAC,GAAG;IAjBxC,8DAA8D;IAC9D,MAAM,CAAC,kBAAkB,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAI7F,iDAAiD;IACjD,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;IAMnE,qCAAqC;IACrC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC;IAI9C,OAAO;IAEP,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAIrB,YAAY,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAWvD,8CAA8C;IAC7C,CAAC,MAAM,CAAC,QAAQ,CAAC;IAMlB,oCAAoC;IACpC,MAAM,CAAC,KAAK,EAAE,CAAC;IAIf,wCAAwC;IACxC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE;IAM9B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,CAAC;CAGhB"}

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

@@ -0,0 +1,61 @@
+import { HashDictionary } from "./hash-dictionary.js";
+/** A set specialized for storing hashes. */
+export class HashSet {
+    map;
+    /** Wrap given dictionary into `HashSet` api for it's keys. */
+    static viewDictionaryKeys(dict) {
+        return new HashSet(dict);
+    }
+    /** Create new set from given array of values. */
+    static from(values) {
+        const newSet = HashSet.new();
+        newSet.insertAll(values);
+        return newSet;
+    }
+    /** Create an empty set of hashes. */
+    static new() {
+        return new HashSet();
+    }
+    constructor(map = HashDictionary.new()) {
+        this.map = map;
+    }
+    get size() {
+        return this.map.size;
+    }
+    has(value) {
+        return this.map.has(value);
+    }
+    *intersection(other) {
+        const iterate = this.size < other.size ? this : other;
+        const second = iterate === this ? other : this;
+        for (const elem of iterate) {
+            if (second.has(elem)) {
+                yield elem;
+            }
+        }
+    }
+    /** it allows to use HashSet in for-of loop */
+    *[Symbol.iterator]() {
+        for (const value of this.map) {
+            yield value[0];
+        }
+    }
+    /** Insert given hash to the set. */
+    insert(value) {
+        return this.map.set(value, true);
+    }
+    /** Insert multiple items to the set. */
+    insertAll(values) {
+        for (const v of values) {
+            this.map.set(v, true);
+        }
+    }
+    /**
+     * Remove value from set.
+     *
+     * Returns `true` if element existed in the set and was removed, `false` otherwise.
+     */
+    delete(value) {
+        return this.map.delete(value);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,49 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { HashSet } from "./hash-set.js";
+function key(n) {
+    return Bytes.fill(HASH_SIZE, n);
+}
+describe("HashSet", () => {
+    it("should return true/false for keys present in the dictionary", () => {
+        const set = HashSet.new();
+        set.insert(key(1));
+        set.insert(key(2));
+        assert.deepStrictEqual(set.has(key(0)), false);
+        assert.deepStrictEqual(set.has(key(1)), true);
+        assert.deepStrictEqual(set.has(key(2)), true);
+        assert.deepStrictEqual(set.has(key(3)), false);
+    });
+    it("should insert multiple elements", () => {
+        const set = HashSet.new();
+        set.insertAll([key(1), key(2)]);
+        assert.deepStrictEqual(set.has(key(1)), true);
+        assert.deepStrictEqual(set.has(key(2)), true);
+    });
+    it("should remove some values", () => {
+        const dict = HashSet.new();
+        dict.insert(key(1));
+        dict.insert(key(2));
+        assert.deepStrictEqual(dict.has(key(1)), true);
+        assert.deepStrictEqual(dict.has(key(2)), true);
+        dict.delete(key(0));
+        dict.delete(key(1));
+        dict.delete(key(3));
+        assert.deepStrictEqual(dict.has(key(0)), false);
+        assert.deepStrictEqual(dict.has(key(1)), false);
+        assert.deepStrictEqual(dict.has(key(2)), true);
+        assert.deepStrictEqual(dict.has(key(3)), false);
+    });
+    it("should return intersection of two sets", () => {
+        const dict1 = HashSet.new();
+        dict1.insertAll([key(1), key(2)]);
+        const dict2 = HashSet.new();
+        dict2.insertAll([key(2), key(3)]);
+        const intersect1 = Array.from(dict1.intersection(dict2));
+        const intersect2 = Array.from(dict2.intersection(dict1));
+        assert.deepStrictEqual(intersect1.toString(), intersect2.toString());
+        assert.deepStrictEqual(intersect1.toString(), "0x0202020202020202020202020202020202020202020202020202020202020202");
+    });
+});

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

@@ -0,0 +1,10 @@
+export * from "./array-view.js";
+export * from "./blob-dictionary.js";
+export * from "./hash-dictionary.js";
+export * from "./hash-set.js";
+export * from "./multi-map.js";
+export * from "./sized-array.js";
+export * from "./sorted-array.js";
+export * from "./sorted-set.js";
+export * from "./truncated-hash-dictionary.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/collections/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gCAAgC,CAAC"}

package/packages/core/collections/index.js

@@ -0,0 +1,9 @@
+export * from "./array-view.js";
+export * from "./blob-dictionary.js";
+export * from "./hash-dictionary.js";
+export * from "./hash-set.js";
+export * from "./multi-map.js";
+export * from "./sized-array.js";
+export * from "./sorted-array.js";
+export * from "./sorted-set.js";
+export * from "./truncated-hash-dictionary.js";

package/packages/core/collections/multi-map.d.ts

@@ -0,0 +1,50 @@
+type NestedMaps<TKeys extends readonly unknown[], TValue> = TKeys extends [infer THead, ...infer TTail] ? Map<THead, NestedMaps<TTail, TValue>> : TValue;
+type KeyMappers<TKeys extends readonly unknown[]> = TKeys extends [infer THead, ...infer TTail] ? [KeyMapper<THead> | null, ...KeyMappers<TTail>] : [];
+/** Key representation that can be stored in a map. */
+export type KeyMapper<K> = (key: K) => string | number | bigint | symbol;
+/**
+ * A multi-key map, implemented as nested maps.
+ *
+ * Nested maps are created lazily and never removed.
+ *
+ * Note that the keys which are not primitive values (`string | number | Symbol`)
+ * most likely need a function that will convert the key into some primitive
+ * representation, otherwise the map will compare only references!
+ */
+export declare class MultiMap<TKeys extends readonly unknown[], TValue> {
+    readonly data: NestedMaps<TKeys, TValue>;
+    private readonly keyMappers;
+    /**
+     * Pass the number of keys and optionally mappers from keys to primitive types
+     * if needed.
+     */
+    constructor(keysLength: TKeys["length"], keyMappers?: KeyMappers<TKeys>);
+    /** Convert input keys into primitive types. */
+    private primitiveKeys;
+    /**
+     * Set given `value` at particular location denoted by `inKeys`.
+     *
+     * The function will create all missing nested maps.
+     */
+    set(value: TValue, ...inKeys: TKeys): this;
+    /**
+     * Remove the entry under `inKeys`.
+     *
+     * NOTE: this function does not remove empty maps.
+     *
+     * Returns `true` if the value was removed or `false` otherwise.
+     */
+    delete(...inKeys: TKeys): boolean;
+    /** Check presence of the value under `inKeys`. */
+    has(...inKeys: TKeys): boolean;
+    /** Get the value under `inKeys` or `undefined` if not present. */
+    get(...inKeys: TKeys): TValue | undefined;
+    /**
+     * Traverse all path except for the last key.
+     *
+     * Returns the last map `Map<LastKey, TValue>` and the last key.
+     */
+    private findLastMapAndKey;
+}
+export {};
+//# sourceMappingURL=multi-map.d.ts.map

package/packages/core/collections/multi-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-map.d.ts","sourceRoot":"","sources":["../../../../../packages/core/collections/multi-map.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,MAAM,IAAI,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,KAAK,CAAC,GACnG,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,GACrC,MAAM,CAAC;AAEX,KAAK,UAAU,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,KAAK,CAAC,GAC3F,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,GAC/C,EAAE,CAAC;AAEP,sDAAsD;AACtD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEzE;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,MAAM;IAC5D,SAAgB,IAAI,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAE/C;;;OAGG;gBACS,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC;IAOvE,+CAA+C;IAC/C,OAAO,CAAC,aAAa;IAOrB;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,KAAK;IAsBnC;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,MAAM,EAAE,KAAK,GAAG,OAAO;IAKjC,kDAAkD;IAClD,GAAG,CAAC,GAAG,MAAM,EAAE,KAAK,GAAG,OAAO;IAK9B,kEAAkE;IAClE,GAAG,CAAC,GAAG,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS;IAKzC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;CA0B1B"}