@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/jam/database/blocks.js

@@ -0,0 +1,49 @@
+import { Bytes } from "#@typeberry/bytes";
+import { HashDictionary } from "#@typeberry/collections";
+import { HASH_SIZE } from "#@typeberry/hash";
+/** In-memory (non-persistent) blocks database. */
+export class InMemoryBlocks {
+    headersByHash = HashDictionary.new();
+    extrinsicsByHeaderHash = HashDictionary.new();
+    postStateRootByHeaderHash = HashDictionary.new();
+    bestHeaderHash = Bytes.zero(HASH_SIZE).asOpaque();
+    /** Create empty blocks db. */
+    static new() {
+        return new InMemoryBlocks();
+    }
+    /** Create new `InMemoryBlocks` and insert all given blocks. */
+    static fromBlocks(previousBlocks) {
+        const blocksDb = InMemoryBlocks.new();
+        for (const block of previousBlocks) {
+            blocksDb.insertBlock(block);
+        }
+        return blocksDb;
+    }
+    constructor() { }
+    setBestHeaderHash(hash) {
+        this.bestHeaderHash = hash;
+        return Promise.resolve();
+    }
+    getBestHeaderHash() {
+        return this.bestHeaderHash;
+    }
+    setPostStateRoot(hash, postStateRoot) {
+        this.postStateRootByHeaderHash.set(hash, postStateRoot);
+        return Promise.resolve();
+    }
+    getPostStateRoot(hash) {
+        return this.postStateRootByHeaderHash.get(hash) ?? null;
+    }
+    insertBlock(block) {
+        this.headersByHash.set(block.hash, block.data.header.view());
+        this.extrinsicsByHeaderHash.set(block.hash, block.data.extrinsic.view());
+        return Promise.resolve();
+    }
+    getHeader(hash) {
+        return this.headersByHash.get(hash) ?? null;
+    }
+    getExtrinsic(hash) {
+        return this.extrinsicsByHeaderHash.get(hash) ?? null;
+    }
+    async close() { }
+}

package/packages/jam/database/blocks.test.d.ts

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

package/packages/jam/database/blocks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.test.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/blocks.test.ts"],"names":[],"mappings":""}

package/packages/jam/database/blocks.test.js

@@ -0,0 +1,31 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { testBlockView } from "#@typeberry/block/test-helpers.js";
+import { Bytes } from "#@typeberry/bytes";
+import { Blake2b, HASH_SIZE, WithHash } from "#@typeberry/hash";
+import { InMemoryBlocks } from "./index.js";
+describe("InMemoryDatabase", () => {
+    let blake2b;
+    before(async () => {
+        blake2b = await Blake2b.createHasher();
+    });
+    it("should set and retrieve best header hash", () => {
+        const db = InMemoryBlocks.new();
+        db.setBestHeaderHash(Bytes.fill(HASH_SIZE, 5).asOpaque());
+        assert.strictEqual(db.getBestHeaderHash().toString(), "0x0505050505050505050505050505050505050505050505050505050505050505");
+    });
+    it("should set and retrieve post state root", () => {
+        const db = InMemoryBlocks.new();
+        db.setPostStateRoot(Bytes.fill(HASH_SIZE, 5).asOpaque(), Bytes.fill(HASH_SIZE, 10).asOpaque());
+        assert.strictEqual(db.getPostStateRoot(Bytes.fill(HASH_SIZE, 1).asOpaque())?.toString(), undefined);
+        assert.strictEqual(db.getPostStateRoot(Bytes.fill(HASH_SIZE, 5).asOpaque())?.toString(), "0x0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a");
+    });
+    it("should store and retrieve a block", () => {
+        const db = InMemoryBlocks.new();
+        const block = testBlockView();
+        const headerHash = blake2b.hashBytes(block.header.view().encoded()).asOpaque();
+        db.insertBlock(new WithHash(headerHash, block));
+        assert.deepStrictEqual(db.getHeader(headerHash)?.materialize(), block.header.materialize());
+        assert.deepStrictEqual(db.getExtrinsic(headerHash)?.materialize(), block.extrinsic.materialize());
+    });
+});

package/packages/jam/database/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./blocks.js";
+export * from "./leaf-db.js";
+export * from "./leaf-db-update.js";
+export * from "./root.js";
+export * from "./serialized-states-db.js";
+export * from "./states.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/database/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,aAAa,CAAC"}

package/packages/jam/database/index.js

@@ -0,0 +1,6 @@
+export * from "./blocks.js";
+export * from "./leaf-db.js";
+export * from "./leaf-db-update.js";
+export * from "./root.js";
+export * from "./serialized-states-db.js";
+export * from "./states.js";

package/packages/jam/database/leaf-db-update.d.ts

@@ -0,0 +1,10 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import type { SortedSet } from "#@typeberry/collections";
+import type { Blake2b, TruncatedHash } from "#@typeberry/hash";
+import { StateEntryUpdateAction, type StateKey } from "#@typeberry/state-merkleization";
+import { type LeafNode, type ValueHash } from "#@typeberry/trie";
+export declare function updateLeafs(leafs: SortedSet<LeafNode>, blake2b: Blake2b, data: Iterable<[StateEntryUpdateAction, StateKey | TruncatedHash, BytesBlob]>): {
+    values: [ValueHash, BytesBlob][];
+    leafs: SortedSet<LeafNode>;
+};
+//# sourceMappingURL=leaf-db-update.d.ts.map

package/packages/jam/database/leaf-db-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf-db-update.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/leaf-db-update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,KAAK,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACvF,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI9E,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,CAAC,QAAQ,CAAC,EAC1B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,QAAQ,CAAC,CAAC,sBAAsB,EAAE,QAAQ,GAAG,aAAa,EAAE,SAAS,CAAC,CAAC,GAC5E;IACD,MAAM,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;IACjC,KAAK,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;CAC5B,CAwBA"}

package/packages/jam/database/leaf-db-update.js

@@ -0,0 +1,31 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { StateEntryUpdateAction } from "#@typeberry/state-merkleization";
+import { InMemoryTrie } from "#@typeberry/trie";
+import { getBlake2bTrieHasher } from "#@typeberry/trie/hasher.js";
+import { assertNever } from "#@typeberry/utils";
+export function updateLeafs(leafs, blake2b, data) {
+    const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
+    // We will collect all values that don't fit directly into leaf nodes.
+    const values = [];
+    for (const [action, key, value] of data) {
+        if (action === StateEntryUpdateAction.Insert) {
+            const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value);
+            leafs.replace(leafNode);
+            if (!leafNode.hasEmbeddedValue()) {
+                values.push([leafNode.getValueHash(), value]);
+            }
+        }
+        else if (action === StateEntryUpdateAction.Remove) {
+            const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), BytesBlob.empty());
+            leafs.removeOne(leafNode);
+            // TODO [ToDr] Handle ref-counting values or updating some header-hash-based references.
+        }
+        else {
+            assertNever(action);
+        }
+    }
+    return {
+        values,
+        leafs,
+    };
+}

package/packages/jam/database/leaf-db.d.ts

@@ -0,0 +1,44 @@
+import type { StateRootHash } from "#@typeberry/block";
+import { BytesBlob } from "#@typeberry/bytes";
+import { SortedSet } from "#@typeberry/collections";
+import type { Blake2b } from "#@typeberry/hash";
+import { type SerializedStateBackend, StateEntries, type StateKey } from "#@typeberry/state-merkleization";
+import { type LeafNode, type ValueHash } from "#@typeberry/trie";
+import { Result } from "#@typeberry/utils";
+/** Error during `LeafDb` creation. */
+export declare enum LeafDbError {
+    InvalidLeafData = 0
+}
+/** Abstraction over access to values that don't fit into leaves. */
+export interface ValuesDb {
+    /**
+     * Retrieve a value under given key.
+     *
+     * Missing value is considered an irrecoverable error, so the implementations
+     * are free to throw if that happens.
+     */
+    get(key: ValueHash): Uint8Array;
+}
+/**
+ * Reads the collection of leaf nodes and convert them into a Map-like structure
+ * that together with some `ValuesDb` may act as `SerializedStateBackend`.
+ *
+ * Note that reading the actual values may require accessing the original database.
+ */
+export declare class LeafDb implements SerializedStateBackend {
+    readonly leafs: SortedSet<LeafNode>;
+    readonly db: ValuesDb;
+    /**
+     * Parse given blob containing concatenated leaf nodes into leaf db.
+     */
+    static fromLeavesBlob(blob: BytesBlob, db: ValuesDb): Result<LeafDb, LeafDbError>;
+    /** Create leaf db from sorted set of leaves. */
+    static fromLeaves(leaves: SortedSet<LeafNode>, db: ValuesDb): LeafDb;
+    /** A mapping between an embedded value or db lookup key. */
+    private readonly lookup;
+    private constructor();
+    get(key: StateKey): BytesBlob | null;
+    getStateRoot(blake2b: Blake2b): StateRootHash;
+    intoStateEntries(): StateEntries;
+}
+//# sourceMappingURL=leaf-db.d.ts.map

package/packages/jam/database/leaf-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf-db.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/leaf-db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAA2B,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,KAAK,sBAAsB,EAAE,YAAY,EAAE,KAAK,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC1G,OAAO,EAEL,KAAK,QAAQ,EAKb,KAAK,SAAS,EACf,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAe,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEvD,sCAAsC;AACtC,oBAAY,WAAW;IACrB,eAAe,IAAI;CACpB;AAED,oEAAoE;AACpE,MAAM,WAAW,QAAQ;IACvB;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,SAAS,GAAG,UAAU,CAAC;CACjC;AAED;;;;;GAKG;AACH,qBAAa,MAAO,YAAW,sBAAsB;aAiCjC,KAAK,EAAE,SAAS,CAAC,QAAQ,CAAC;aAC1B,EAAE,EAAE,QAAQ;IAjC9B;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAoBjF,gDAAgD;IAChD,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,QAAQ,GAAG,MAAM;IAIpE,4DAA4D;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;IAEnE,OAAO;IAqBP,GAAG,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI;IAiBpC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa;IAK7C,gBAAgB,IAAI,YAAY;CAiBjC"}

package/packages/jam/database/leaf-db.js

@@ -0,0 +1,99 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { SortedSet, TruncatedHashDictionary } from "#@typeberry/collections";
+import { StateEntries } from "#@typeberry/state-merkleization";
+import { InMemoryTrie, leafComparator, NodeType, TRIE_NODE_BYTES, TrieNode, } from "#@typeberry/trie";
+import { getBlake2bTrieHasher } from "#@typeberry/trie/hasher.js";
+import { assertNever, Result } from "#@typeberry/utils";
+/** Error during `LeafDb` creation. */
+export var LeafDbError;
+(function (LeafDbError) {
+    LeafDbError[LeafDbError["InvalidLeafData"] = 0] = "InvalidLeafData";
+})(LeafDbError || (LeafDbError = {}));
+/**
+ * Reads the collection of leaf nodes and convert them into a Map-like structure
+ * that together with some `ValuesDb` may act as `SerializedStateBackend`.
+ *
+ * Note that reading the actual values may require accessing the original database.
+ */
+export class LeafDb {
+    leafs;
+    db;
+    /**
+     * Parse given blob containing concatenated leaf nodes into leaf db.
+     */
+    static fromLeavesBlob(blob, db) {
+        if (blob.length % TRIE_NODE_BYTES !== 0) {
+            return Result.error(LeafDbError.InvalidLeafData, () => `${blob.length} is not a multiply of ${TRIE_NODE_BYTES}: ${blob}`);
+        }
+        const leaves = SortedSet.fromArray(leafComparator, []);
+        for (const nodeData of blob.chunks(TRIE_NODE_BYTES)) {
+            const node = new TrieNode(nodeData.raw);
+            if (node.getNodeType() === NodeType.Branch) {
+                return Result.error(LeafDbError.InvalidLeafData, () => `Branch node detected: ${nodeData}`);
+            }
+            leaves.insert(node.asLeafNode());
+        }
+        return Result.ok(new LeafDb(leaves, db));
+    }
+    /** Create leaf db from sorted set of leaves. */
+    static fromLeaves(leaves, db) {
+        return new LeafDb(leaves, db);
+    }
+    /** A mapping between an embedded value or db lookup key. */
+    lookup;
+    constructor(leafs, db) {
+        this.leafs = leafs;
+        this.db = db;
+        this.lookup = TruncatedHashDictionary.fromEntries(leafs.array.map((leaf) => {
+            const key = leaf.getKey().asOpaque();
+            const value = leaf.hasEmbeddedValue()
+                ? {
+                    kind: LookupKind.EmbeddedValue,
+                    value: leaf.getValue(),
+                }
+                : {
+                    kind: LookupKind.DbKey,
+                    key: leaf.getValueHash(),
+                };
+            return [key, value];
+        }));
+    }
+    get(key) {
+        const val = this.lookup.get(key);
+        if (val === undefined) {
+            return null;
+        }
+        if (val.kind === LookupKind.EmbeddedValue) {
+            return val.value;
+        }
+        if (val.kind === LookupKind.DbKey) {
+            return BytesBlob.blobFrom(this.db.get(val.key));
+        }
+        assertNever(val);
+    }
+    getStateRoot(blake2b) {
+        const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
+        return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leafs).asOpaque();
+    }
+    intoStateEntries() {
+        const entries = [];
+        for (const [key, lookup] of this.lookup.entries()) {
+            switch (lookup.kind) {
+                case LookupKind.EmbeddedValue:
+                    entries.push([key.asOpaque(), lookup.value]);
+                    continue;
+                case LookupKind.DbKey:
+                    entries.push([key.asOpaque(), BytesBlob.blobFrom(this.db.get(lookup.key))]);
+                    continue;
+                default:
+                    assertNever(lookup);
+            }
+        }
+        return StateEntries.fromEntriesUnsafe(entries);
+    }
+}
+var LookupKind;
+(function (LookupKind) {
+    LookupKind[LookupKind["EmbeddedValue"] = 0] = "EmbeddedValue";
+    LookupKind[LookupKind["DbKey"] = 1] = "DbKey";
+})(LookupKind || (LookupKind = {}));

package/packages/jam/database/leaf-db.test.d.ts

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

package/packages/jam/database/leaf-db.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf-db.test.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/leaf-db.test.ts"],"names":[],"mappings":""}

package/packages/jam/database/leaf-db.test.js

@@ -0,0 +1,93 @@
+import assert, { deepEqual } from "node:assert";
+import { before, describe, it } from "node:test";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Blake2b, HASH_SIZE, TRUNCATED_HASH_SIZE } from "#@typeberry/hash";
+import { InMemoryTrie } from "#@typeberry/trie";
+import { getBlake2bTrieHasher } from "#@typeberry/trie/hasher.js";
+import { resultToString } from "#@typeberry/utils";
+import { LeafDb } from "./leaf-db.js";
+let blake2bTrieHasher;
+let blake2b;
+before(async () => {
+    blake2b = await Blake2b.createHasher();
+    blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
+});
+describe("LeafDb", () => {
+    it("should construct a LeafDb", () => {
+        const leafDbRes = constructLeafDb([
+            [Bytes.fill(HASH_SIZE, 1).asOpaque(), BytesBlob.blobFromString("val1")],
+            [Bytes.fill(HASH_SIZE, 2).asOpaque(), BytesBlob.blobFromString("val2")],
+        ]);
+        const leafDb = assertOk(leafDbRes);
+        // when
+        const val1 = leafDb.get(Bytes.fill(HASH_SIZE, 1).asOpaque());
+        const val2 = leafDb.get(Bytes.fill(HASH_SIZE, 2).asOpaque());
+        const val3 = leafDb.get(Bytes.fill(HASH_SIZE, 3).asOpaque());
+        assert.strictEqual(`${val1}`, `${BytesBlob.blobFromString("val1")}`);
+        assert.strictEqual(`${val2}`, "0x76616c32");
+        assert.strictEqual(val3, null);
+    });
+    it("should retrieve value from a DB", () => {
+        const raw = [
+            [Bytes.fill(HASH_SIZE, 1).asOpaque(), Bytes.fill(128, 0xff)],
+            [Bytes.fill(HASH_SIZE, 2).asOpaque(), Bytes.fill(129, 0xee)],
+            [Bytes.fill(HASH_SIZE, 3).asOpaque(), BytesBlob.blobFromString("val1")],
+            [Bytes.fill(HASH_SIZE, 4).asOpaque(), BytesBlob.blobFromString("val2")],
+        ];
+        const leafDbRes = constructLeafDb(raw);
+        const leafDb = assertOk(leafDbRes);
+        // when
+        const entries = leafDb.intoStateEntries();
+        // then
+        deepEqual(Array.from(entries), raw.map(([a, b]) => [Bytes.fromBlob(a.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE).asOpaque(), b]));
+    });
+    it("should convert into state entries", () => {
+        const leafDbRes = constructLeafDb([
+            [Bytes.fill(HASH_SIZE, 1).asOpaque(), Bytes.fill(128, 0xff)],
+            [Bytes.fill(HASH_SIZE, 2).asOpaque(), Bytes.fill(129, 0xee)],
+        ]);
+        const leafDb = assertOk(leafDbRes);
+        // when
+        const val1 = leafDb.get(Bytes.fill(HASH_SIZE, 1).asOpaque());
+        const val2 = leafDb.get(Bytes.fill(HASH_SIZE, 2).asOpaque());
+        const val3 = leafDb.get(Bytes.fill(HASH_SIZE, 3).asOpaque());
+        assert.strictEqual(`${val1}`, `${Bytes.fill(128, 0xff)}`);
+        assert.strictEqual(`${val2}`, `${Bytes.fill(129, 0xee)}`);
+        assert.strictEqual(val3, null);
+    });
+    it("should fail on invalid blob data", () => {
+        const res = LeafDb.fromLeavesBlob(BytesBlob.blobFromNumbers([1, 2, 3]), dbFromRaw(new Map()));
+        assert.strictEqual(`${resultToString(res)}`, "3 is not a multiply of 64: 0x010203\nError: 0");
+    });
+});
+function assertOk(res) {
+    if (res.isError) {
+        assert.fail(`Expected LeafDb to be created correctly, got: ${resultToString(res)}`);
+    }
+    return res.ok;
+}
+function constructLeafDb(entries) {
+    const rawDb = new Map();
+    const trie = InMemoryTrie.empty(blake2bTrieHasher);
+    for (const [key, value] of entries) {
+        const leafNode = trie.set(key, value);
+        if (!leafNode.hasEmbeddedValue()) {
+            // we need to put it to the DB, since it didn't fit into the leaf.
+            rawDb.set(`${leafNode.getValueHash()}`, value);
+        }
+    }
+    const leafNodes = Array.from(trie.nodes.leaves());
+    const db = dbFromRaw(rawDb);
+    return LeafDb.fromLeavesBlob(BytesBlob.blobFromParts(leafNodes.map((x) => x.node.raw)), db);
+}
+function dbFromRaw(rawDb) {
+    return {
+        get(key) {
+            const v = rawDb.get(`${key}`);
+            if (v === undefined) {
+                throw new Error(`Missing key: ${key}`);
+            }
+            return v.raw;
+        },
+    };
+}

package/packages/jam/database/root.d.ts

@@ -0,0 +1,12 @@
+import type { BlocksDb } from "./blocks.js";
+import type { StatesDb } from "./states.js";
+/** Root database. */
+export interface RootDb<TBlocks = BlocksDb, TStates = StatesDb> {
+    /** Blocks DB. */
+    getBlocksDb(): TBlocks;
+    /** States DB. */
+    getStatesDb(): TStates;
+    /** Close access to the DB. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=root.d.ts.map

package/packages/jam/database/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/root.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,qBAAqB;AACrB,MAAM,WAAW,MAAM,CAAC,OAAO,GAAG,QAAQ,EAAE,OAAO,GAAG,QAAQ;IAC5D,iBAAiB;IACjB,WAAW,IAAI,OAAO,CAAC;IAEvB,iBAAiB;IACjB,WAAW,IAAI,OAAO,CAAC;IAEvB,8BAA8B;IAC9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/packages/jam/database/root.js

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

package/packages/jam/database/serialized-states-db.d.ts

@@ -0,0 +1,32 @@
+import type { HeaderHash, StateRootHash } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import { Blake2b } from "#@typeberry/hash";
+import type { State } from "#@typeberry/state/state.js";
+import type { ServicesUpdate } from "#@typeberry/state/state-update.js";
+import { SerializedState, type StateEntries } from "#@typeberry/state-merkleization";
+import { OK, Result } from "#@typeberry/utils";
+import { LeafDb } from "./leaf-db.js";
+import type { InitStatesDb, StatesDb, StateUpdateError } from "./states.js";
+/** Abstract serialized-states db. */
+export type SerializedStatesDb = StatesDb<SerializedState<LeafDb>> & InitStatesDb<StateEntries>;
+/** In-memory serialized-states db. */
+export declare class InMemorySerializedStates implements StatesDb<SerializedState<LeafDb>>, InitStatesDb<StateEntries> {
+    private readonly spec;
+    private readonly blake2b;
+    private readonly db;
+    private readonly valuesDb;
+    static new({ chainSpec }: {
+        chainSpec: ChainSpec;
+    }): Promise<InMemorySerializedStates>;
+    static withHasher({ chainSpec, blake2b }: {
+        chainSpec: ChainSpec;
+        blake2b: Blake2b;
+    }): InMemorySerializedStates;
+    private constructor();
+    insertInitialState(headerHash: HeaderHash, entries: StateEntries): Promise<Result<OK, StateUpdateError>>;
+    getStateRoot(state: SerializedState<LeafDb>): Promise<StateRootHash>;
+    updateAndSetState(header: HeaderHash, state: SerializedState<LeafDb>, update: Partial<State & ServicesUpdate>): Promise<Result<OK, StateUpdateError>>;
+    getState(header: HeaderHash): SerializedState<LeafDb> | null;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=serialized-states-db.d.ts.map

package/packages/jam/database/serialized-states-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialized-states-db.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/serialized-states-db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EACL,eAAe,EACf,KAAK,YAAY,EAGlB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE5E,qCAAqC;AACrC,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEhG,sCAAsC;AACtC,qBAAa,wBAAyB,YAAW,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC;IAc1G,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAd1B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAyE;IAC5F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8D;WAE1E,GAAG,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE;IAKxD,MAAM,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;QAAE,SAAS,EAAE,SAAS,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE;IAIpF,OAAO;IAKD,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAiBxG,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAIpE,iBAAiB,CACrB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,EAC9B,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAsBxC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,IAAI;IAkBtD,KAAK;CACZ"}

package/packages/jam/database/serialized-states-db.js

@@ -0,0 +1,74 @@
+import { HashDictionary, SortedSet } from "#@typeberry/collections";
+import { Blake2b } from "#@typeberry/hash";
+import { SerializedState, StateEntryUpdateAction, serializeStateUpdate, } from "#@typeberry/state-merkleization";
+import { leafComparator } from "#@typeberry/trie";
+import { OK, Result } from "#@typeberry/utils";
+import { LeafDb } from "./leaf-db.js";
+import { updateLeafs } from "./leaf-db-update.js";
+/** In-memory serialized-states db. */
+export class InMemorySerializedStates {
+    spec;
+    blake2b;
+    db = HashDictionary.new();
+    valuesDb = HashDictionary.new();
+    static async new({ chainSpec }) {
+        const blake2b = await Blake2b.createHasher();
+        return new InMemorySerializedStates(chainSpec, blake2b);
+    }
+    static withHasher({ chainSpec, blake2b }) {
+        return new InMemorySerializedStates(chainSpec, blake2b);
+    }
+    constructor(spec, blake2b) {
+        this.spec = spec;
+        this.blake2b = blake2b;
+    }
+    async insertInitialState(headerHash, entries) {
+        // convert state entries into leafdb
+        const { values, leafs } = updateLeafs(SortedSet.fromArray(leafComparator, []), this.blake2b, Array.from(entries, (x) => [StateEntryUpdateAction.Insert, x[0], x[1]]));
+        // insert values to the db.
+        for (const val of values) {
+            this.valuesDb.set(val[0], val[1]);
+        }
+        this.db.set(headerHash, leafs);
+        return Result.ok(OK);
+    }
+    async getStateRoot(state) {
+        return state.backend.getStateRoot(this.blake2b);
+    }
+    async updateAndSetState(header, state, update) {
+        const blake2b = this.blake2b;
+        const updatedValues = serializeStateUpdate(this.spec, blake2b, update);
+        // make sure to clone the leafs before writing, since the collection is re-used.
+        const newLeafs = SortedSet.fromSortedArray(leafComparator, state.backend.leafs.array);
+        const { values, leafs } = updateLeafs(newLeafs, blake2b, updatedValues);
+        // make sure to reset the cache and re-create leafsdb lookup
+        state.updateBackend(LeafDb.fromLeaves(leafs, state.backend.db));
+        // insert values to the db
+        // valuesdb can be shared between all states because it's just
+        // <valuehash> -> <value> mapping and existence is managed by trie leafs.
+        for (const val of values) {
+            this.valuesDb.set(val[0], val[1]);
+        }
+        // store new set of leaves
+        this.db.set(header, leafs);
+        return Result.ok(OK);
+    }
+    getState(header) {
+        const leafs = this.db.get(header);
+        if (leafs === undefined) {
+            return null;
+        }
+        // now create a leafdb with shared values db.
+        const leafDb = LeafDb.fromLeaves(leafs, {
+            get: (key) => {
+                const val = this.valuesDb.get(key);
+                if (val === undefined) {
+                    throw new Error(`Missing value at key: ${key}`);
+                }
+                return val.raw;
+            },
+        });
+        return SerializedState.new(this.spec, this.blake2b, leafDb);
+    }
+    async close() { }
+}

package/packages/jam/database/states.d.ts

@@ -0,0 +1,51 @@
+import type { HeaderHash, StateRootHash } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import { InMemoryState, type ServicesUpdate, type State } from "#@typeberry/state";
+import { OK, Result } from "#@typeberry/utils";
+/** A potential error that occured during state update. */
+export declare enum StateUpdateError {
+    /** A conflicting state update has been provided. */
+    Conflict = 0,
+    /** There was an error committing the changes. */
+    Commit = 1
+}
+/** Interface to initialize states db. Typically used in conjunction with `StatesDb`. */
+export interface InitStatesDb<T = State> {
+    /** Insert a pre-defined initial state directly into the database. */
+    insertInitialState(headerHash: HeaderHash, initialState: T): Promise<Result<OK, StateUpdateError>>;
+}
+/**
+ * Interface for accessing states stored in the database.
+ *
+ * NOTE that the design of this interface is heavily influenced
+ * by the LMDB implementation, so that we can implement it efficiently.
+ *
+ * See the documentation there for more detailed reasoning.
+ */
+export interface StatesDb<T extends State = State> {
+    /** Compute a state root for given state. */
+    getStateRoot(state: T): Promise<StateRootHash>;
+    /**
+     * Apply & commit a state update.
+     *
+     * NOTE: for efficiency, the implementation MAY alter given `state` object.
+     */
+    updateAndSetState(header: HeaderHash, state: T, update: Partial<State & ServicesUpdate>): Promise<Result<OK, StateUpdateError>>;
+    /** Retrieve posterior state of given header. */
+    getState(header: HeaderHash): T | null;
+    /** Close the database and free resources. */
+    close(): Promise<void>;
+}
+export declare class InMemoryStates implements StatesDb<InMemoryState> {
+    private readonly spec;
+    private readonly db;
+    private readonly blake2b;
+    constructor(spec: ChainSpec);
+    updateAndSetState(headerHash: HeaderHash, state: InMemoryState, update: Partial<State & ServicesUpdate>): Promise<Result<OK, StateUpdateError>>;
+    getStateRoot(state: InMemoryState): Promise<StateRootHash>;
+    /** Insert a full state into the database. */
+    insertInitialState(headerHash: HeaderHash, state: InMemoryState): Promise<Result<OK, StateUpdateError>>;
+    getState(headerHash: HeaderHash): InMemoryState | null;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=states.d.ts.map

package/packages/jam/database/states.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"states.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/states.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,KAAK,EAAe,MAAM,kBAAkB,CAAC;AAE/F,OAAO,EAAe,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE3D,0DAA0D;AAC1D,oBAAY,gBAAgB;IAC1B,oDAAoD;IACpD,QAAQ,IAAI;IACZ,iDAAiD;IACjD,MAAM,IAAI;CACX;AAED,wFAAwF;AACxF,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,KAAK;IACrC,qEAAqE;IACrE,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC;CACpG;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK;IAC/C,4CAA4C;IAC5C,YAAY,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAE/C;;;;OAIG;IACH,iBAAiB,CACf,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAEzC,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC;IAEvC,6CAA6C;IAC7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,qBAAa,cAAe,YAAW,QAAQ,CAAC,aAAa,CAAC;IAIhD,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHjC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAmE;IACtF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;gBAEd,IAAI,EAAE,SAAS;IAItC,iBAAiB,CACrB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,GACtC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAgBlC,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAKhE,6CAA6C;IACvC,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAM7G,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI;IAShD,KAAK;CACZ"}

package/packages/jam/database/states.js

@@ -0,0 +1,54 @@
+import { HashDictionary } from "#@typeberry/collections";
+import { Blake2b } from "#@typeberry/hash";
+import { InMemoryState, UpdateError } from "#@typeberry/state";
+import { StateEntries } from "#@typeberry/state-merkleization";
+import { assertNever, OK, Result } from "#@typeberry/utils";
+/** A potential error that occured during state update. */
+export var StateUpdateError;
+(function (StateUpdateError) {
+    /** A conflicting state update has been provided. */
+    StateUpdateError[StateUpdateError["Conflict"] = 0] = "Conflict";
+    /** There was an error committing the changes. */
+    StateUpdateError[StateUpdateError["Commit"] = 1] = "Commit";
+})(StateUpdateError || (StateUpdateError = {}));
+export class InMemoryStates {
+    spec;
+    db = HashDictionary.new();
+    blake2b;
+    constructor(spec) {
+        this.spec = spec;
+        this.blake2b = Blake2b.createHasher();
+    }
+    async updateAndSetState(headerHash, state, update) {
+        const res = state.applyUpdate(update);
+        if (res.isOk) {
+            return await this.insertInitialState(headerHash, state);
+        }
+        switch (res.error) {
+            case UpdateError.DuplicateService:
+            case UpdateError.NoService:
+            case UpdateError.PreimageExists:
+                return Result.error(StateUpdateError.Conflict, res.details);
+            default:
+                assertNever(res.error);
+        }
+    }
+    async getStateRoot(state) {
+        const blake2b = await this.blake2b;
+        return StateEntries.serializeInMemory(this.spec, blake2b, state).getRootHash(blake2b);
+    }
+    /** Insert a full state into the database. */
+    async insertInitialState(headerHash, state) {
+        const copy = InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
+        this.db.set(headerHash, copy);
+        return Result.ok(OK);
+    }
+    getState(headerHash) {
+        const state = this.db.get(headerHash);
+        if (state === undefined) {
+            return null;
+        }
+        return InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
+    }
+    async close() { }
+}