@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { TEST_STATE_ROOT, testState } from "#@typeberry/state/test.utils.js";
+import { deepEqual } from "#@typeberry/utils";
+import { InMemoryStates } from "./states.js";
+describe("InMemoryState", () => {
+    it("should write and read some state", async () => {
+        const db = new InMemoryStates(tinyChainSpec);
+        const root = Bytes.parseBytes(TEST_STATE_ROOT, HASH_SIZE).asOpaque();
+        deepEqual(db.getState(root), null);
+        await db.insertInitialState(root, testState());
+        deepEqual(db.getState(root), testState());
+    });
+});

package/packages/jam/database-lmdb/blocks.d.ts

@@ -0,0 +1,22 @@
+import { type BlockView, type ExtrinsicView, type HeaderHash, type HeaderView, type StateRootHash } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import type { BlocksDb } from "#@typeberry/database/blocks.js";
+import { type WithHash } from "#@typeberry/hash";
+import type { LmdbRoot } from "./root.js";
+export declare class LmdbBlocks implements BlocksDb {
+    private readonly chainSpec;
+    private readonly root;
+    private readonly extrinsics;
+    private readonly headers;
+    private readonly postStateRoots;
+    constructor(chainSpec: ChainSpec, root: LmdbRoot);
+    setPostStateRoot(hash: HeaderHash, postStateRoot: StateRootHash): Promise<void>;
+    getPostStateRoot(hash: HeaderHash): StateRootHash | null;
+    insertBlock(block: WithHash<HeaderHash, BlockView>): Promise<void>;
+    setBestHeaderHash(hash: HeaderHash): Promise<void>;
+    getBestHeaderHash(): HeaderHash;
+    getHeader(hash: HeaderHash): HeaderView | null;
+    getExtrinsic(hash: HeaderHash): ExtrinsicView | null;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=blocks.d.ts.map

package/packages/jam/database-lmdb/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database-lmdb/blocks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,aAAa,EAElB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAS,MAAM,WAAW,CAAC;AAQjD,qBAAa,UAAW,YAAW,QAAQ;IAMvC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IANvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;gBAGpB,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,QAAQ;IAa3B,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrF,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI;IAQlD,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IASlE,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxD,iBAAiB,IAAI,UAAU;IAS/B,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI;IAS9C,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI;IAQ9C,KAAK;CAGZ"}

package/packages/jam/database-lmdb/blocks.js

@@ -0,0 +1,74 @@
+import { Extrinsic, Header, } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { Decoder } from "#@typeberry/codec";
+import { HASH_SIZE } from "#@typeberry/hash";
+const BEST_BLOCK = "best hash and posterior state root";
+// TODO [ToDr] consider having a changeset for transactions,
+// where we store all `insert ++ key ++ value` and `remove ++ key`
+// in a single `Uint8Array` JAM-encoded. That could then
+// be efficiently transferred between threads.
+export class LmdbBlocks {
+    chainSpec;
+    root;
+    extrinsics;
+    headers;
+    postStateRoots;
+    constructor(chainSpec, root) {
+        this.chainSpec = chainSpec;
+        this.root = root;
+        // NOTE [ToDr] Extrinsics are stored under header hash, not their hash. Revise if it's an issue.
+        this.extrinsics = this.root.subDb("extrinsics");
+        this.headers = this.root.subDb("headers");
+        // NOTE [ToDr] We currently store all posterior state roots, however it's
+        // most likely very redundant. We probably only need to store the posterior
+        // state roots of recent blocks to be able to quickly resolve forks
+        // OR we need a way to be able to traverse the blocks history forward
+        // (i.e. know what next block(s) is).
+        this.postStateRoots = this.root.subDb("postStateRoots");
+    }
+    async setPostStateRoot(hash, postStateRoot) {
+        await this.postStateRoots.put(hash.raw, postStateRoot.raw);
+    }
+    getPostStateRoot(hash) {
+        const postStateRoot = this.postStateRoots.get(hash.raw);
+        if (postStateRoot === undefined) {
+            return null;
+        }
+        return Bytes.fromBlob(postStateRoot, HASH_SIZE).asOpaque();
+    }
+    async insertBlock(block) {
+        const header = block.data.header.view().encoded();
+        const extrinsic = block.data.extrinsic.view().encoded();
+        await this.root.db.transaction(() => {
+            this.headers.put(block.hash.raw, header.raw);
+            this.extrinsics.put(block.hash.raw, extrinsic.raw);
+        });
+    }
+    async setBestHeaderHash(hash) {
+        await this.root.db.put(BEST_BLOCK, hash.raw);
+    }
+    getBestHeaderHash() {
+        const bestHeaderHash = this.root.db.get(BEST_BLOCK);
+        if (bestHeaderHash === undefined) {
+            return Bytes.zero(HASH_SIZE).asOpaque();
+        }
+        return Bytes.fromBlob(bestHeaderHash, HASH_SIZE).asOpaque();
+    }
+    getHeader(hash) {
+        const data = this.headers.get(hash.raw);
+        if (data === undefined) {
+            return null;
+        }
+        return Decoder.decodeObject(Header.Codec.View, data, this.chainSpec);
+    }
+    getExtrinsic(hash) {
+        const data = this.extrinsics.get(hash.raw);
+        if (data === undefined) {
+            return null;
+        }
+        return Decoder.decodeObject(Extrinsic.Codec.View, data, this.chainSpec);
+    }
+    async close() {
+        await Promise.all([this.headers.close(), this.extrinsics.close(), this.postStateRoots.close()]);
+    }
+}

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

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

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

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

package/packages/jam/database-lmdb/index.js

@@ -0,0 +1,3 @@
+export * from "./blocks.js";
+export * from "./root.js";
+export * from "./states.js";

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

@@ -0,0 +1,12 @@
+import * as lmdb from "lmdb";
+export type SubDb = lmdb.Database<Uint8Array, lmdb.Key>;
+/** A thin abstraction over lmdb database interface. */
+export declare class LmdbRoot {
+    readonly db: lmdb.RootDatabase<Uint8Array, lmdb.Key>;
+    constructor(dbPath: string, readOnly?: boolean);
+    /** Open a sub-database under the same path. */
+    subDb(name: string): SubDb;
+    /** Close the database and all sub-databases. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=root.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database-lmdb/root.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,MAAM,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;AAExD,uDAAuD;AACvD,qBAAa,QAAQ;IACnB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;gBAEzC,MAAM,EAAE,MAAM,EAAE,QAAQ,UAAQ;IAS5C,+CAA+C;IAC/C,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAI1B,gDAAgD;IAC1C,KAAK;CAGZ"}

package/packages/jam/database-lmdb/root.js

@@ -0,0 +1,21 @@
+import * as lmdb from "lmdb";
+/** A thin abstraction over lmdb database interface. */
+export class LmdbRoot {
+    db;
+    constructor(dbPath, readOnly = false) {
+        this.db = lmdb.open(dbPath, {
+            compression: true,
+            keyEncoding: "binary",
+            encoding: "binary",
+            readOnly,
+        });
+    }
+    /** Open a sub-database under the same path. */
+    subDb(name) {
+        return this.db.openDB({ name });
+    }
+    /** Close the database and all sub-databases. */
+    async close() {
+        await this.db.close();
+    }
+}

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

@@ -0,0 +1,72 @@
+import type { HeaderHash, StateRootHash } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import { type InitStatesDb, LeafDb, type StatesDb, StateUpdateError } from "#@typeberry/database";
+import type { Blake2b } from "#@typeberry/hash";
+import type { ServicesUpdate, State } from "#@typeberry/state";
+import type { StateEntries } from "#@typeberry/state-merkleization";
+import { SerializedState } from "#@typeberry/state-merkleization";
+import { OK, Result } from "#@typeberry/utils";
+import type { LmdbRoot } from "./root.js";
+/**
+ * LMDB-backed state storage.
+ *
+ * Assumptions:
+ * 1. For each block we end up with some posterior state.
+ * 2. Majority of state entries will stay the same, however there are some that always change.
+ * 3. We rarely need `stateRoot`, only needed to verify that we importing a
+ *    block on the correct state.
+ * 4. We rarely need intermediate trie nodes, only needed for answering warp-sync (CE129)
+ *    and producing state proofs.
+ *
+ * The trie for JAM is designed so that every node takes exactly 64 bytes. Values
+ * that don't fit directly into a trie node (larger than 32bytes) are hash-referenced
+ * there.
+ * Thanks to this, we can estimate that for each and every state, all of the leaf nodes
+ * "should not take a lot". Let's assume that we have:
+ * 1. 999 services
+ * 2. Each service has 50 preimages, so also roughly 50 preimage lookups.
+ * 3. On top of that we have 899 storage entries (arbitrary size)
+ * 4. That gives us roughly 1000 trie leaves for each service (50 + 50 + 899 + 1(info))
+ * 5. We have 15 always-present storage entries (let's round it up to 1k)
+ *
+ * Hence in total we should have 999 * 1000 + 15 ~ 1M leaves.
+ * So for every state, all of the leaves should occupy roughly `64B * 1M = 64MB`.
+ * Large values that do not change, are automatically deduplicated via hash-references.
+ *
+ * It seems very sensible then to:
+ * 1. Just store trie leaves for each state.
+ * 2. Prune old (finalized) states (otherwise 24h of states = 14400 blocks * 64MB ~ 1TB)
+ * 3. Recompute the trie in-memory only if needed.
+ *
+ * Obviously from just the leaf nodes we can easily obtain the entire state.
+ *
+ * That's the approach we are implementing here (for now without pruning:)).
+ *
+ * Since when referencing some state we always think of it in terms of a posterior
+ * state produced by some block, we use `HeaderHash` to index the leaf collections.
+ *
+ * The state root (if needed) can be easily recomputed by merkelizing the leaves.
+ *
+ * We might need to implement some reference counting for values, or at least
+ * know the last state that is referencing them, so that they can be purged from
+ * the `values` database when they are not needed any more.
+ *
+ * TODO [ToDr] To implement when actually needed:
+ * - [ ] state pruning on finality / pre-defined window (warp threshold?)
+ * - [ ] removing unused values
+ */
+export declare class LmdbStates implements StatesDb<SerializedState<LeafDb>>, InitStatesDb<StateEntries> {
+    private readonly spec;
+    private readonly blake2b;
+    private readonly root;
+    private readonly states;
+    private readonly values;
+    constructor(spec: ChainSpec, blake2b: Blake2b, root: LmdbRoot);
+    insertInitialState(headerHash: HeaderHash, serializedState: StateEntries): Promise<Result<OK, StateUpdateError>>;
+    private updateAndCommit;
+    updateAndSetState(headerHash: HeaderHash, state: SerializedState<LeafDb>, update: Partial<State & ServicesUpdate>): Promise<Result<OK, StateUpdateError>>;
+    getStateRoot(state: SerializedState<LeafDb>): Promise<StateRootHash>;
+    getState(root: HeaderHash): SerializedState<LeafDb> | null;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=states.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"states.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database-lmdb/states.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,KAAK,YAAY,EAAE,MAAM,EAAE,KAAK,QAAQ,EAAE,gBAAgB,EAAe,MAAM,qBAAqB,CAAC;AAC9G,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAgD,MAAM,gCAAgC,CAAC;AAG/G,OAAO,EAAE,EAAE,EAAE,MAAM,EAAkB,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAS,MAAM,WAAW,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,qBAAa,UAAW,YAAW,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC;IAK5F,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IANvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAGZ,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,QAAQ;IAM3B,kBAAkB,CACtB,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,YAAY,GAC5B,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;YAQ1B,eAAe;IA0BvB,iBAAiB,CACrB,UAAU,EAAE,UAAU,EACtB,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;IAWlC,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAI1E,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,IAAI;IAsBpD,KAAK;CAGZ"}

package/packages/jam/database-lmdb/states.js

@@ -0,0 +1,131 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { SortedSet } from "#@typeberry/collections";
+import { LeafDb, StateUpdateError, updateLeafs } from "#@typeberry/database";
+import { Logger } from "#@typeberry/logger";
+import { SerializedState, StateEntryUpdateAction, serializeStateUpdate } from "#@typeberry/state-merkleization";
+import { leafComparator } from "#@typeberry/trie";
+import { OK, Result, resultToString } from "#@typeberry/utils";
+const logger = Logger.new(import.meta.filename, "db");
+/**
+ * LMDB-backed state storage.
+ *
+ * Assumptions:
+ * 1. For each block we end up with some posterior state.
+ * 2. Majority of state entries will stay the same, however there are some that always change.
+ * 3. We rarely need `stateRoot`, only needed to verify that we importing a
+ *    block on the correct state.
+ * 4. We rarely need intermediate trie nodes, only needed for answering warp-sync (CE129)
+ *    and producing state proofs.
+ *
+ * The trie for JAM is designed so that every node takes exactly 64 bytes. Values
+ * that don't fit directly into a trie node (larger than 32bytes) are hash-referenced
+ * there.
+ * Thanks to this, we can estimate that for each and every state, all of the leaf nodes
+ * "should not take a lot". Let's assume that we have:
+ * 1. 999 services
+ * 2. Each service has 50 preimages, so also roughly 50 preimage lookups.
+ * 3. On top of that we have 899 storage entries (arbitrary size)
+ * 4. That gives us roughly 1000 trie leaves for each service (50 + 50 + 899 + 1(info))
+ * 5. We have 15 always-present storage entries (let's round it up to 1k)
+ *
+ * Hence in total we should have 999 * 1000 + 15 ~ 1M leaves.
+ * So for every state, all of the leaves should occupy roughly `64B * 1M = 64MB`.
+ * Large values that do not change, are automatically deduplicated via hash-references.
+ *
+ * It seems very sensible then to:
+ * 1. Just store trie leaves for each state.
+ * 2. Prune old (finalized) states (otherwise 24h of states = 14400 blocks * 64MB ~ 1TB)
+ * 3. Recompute the trie in-memory only if needed.
+ *
+ * Obviously from just the leaf nodes we can easily obtain the entire state.
+ *
+ * That's the approach we are implementing here (for now without pruning:)).
+ *
+ * Since when referencing some state we always think of it in terms of a posterior
+ * state produced by some block, we use `HeaderHash` to index the leaf collections.
+ *
+ * The state root (if needed) can be easily recomputed by merkelizing the leaves.
+ *
+ * We might need to implement some reference counting for values, or at least
+ * know the last state that is referencing them, so that they can be purged from
+ * the `values` database when they are not needed any more.
+ *
+ * TODO [ToDr] To implement when actually needed:
+ * - [ ] state pruning on finality / pre-defined window (warp threshold?)
+ * - [ ] removing unused values
+ */
+export class LmdbStates {
+    spec;
+    blake2b;
+    root;
+    states;
+    values;
+    constructor(spec, blake2b, root) {
+        this.spec = spec;
+        this.blake2b = blake2b;
+        this.root = root;
+        this.states = this.root.subDb("states");
+        this.values = this.root.subDb("values");
+    }
+    async insertInitialState(headerHash, serializedState) {
+        return await this.updateAndCommit(headerHash, SortedSet.fromArray(leafComparator, []), Array.from(serializedState, (x) => [StateEntryUpdateAction.Insert, x[0], x[1]]));
+    }
+    async updateAndCommit(headerHash, leafs, data) {
+        const { values } = updateLeafs(leafs, this.blake2b, data);
+        // TODO [ToDr] could be optimized to already have leaves written to one big chunk
+        // (we could pre-allocate one buffer for all the leafs)
+        const stateLeafs = BytesBlob.blobFromParts(leafs.array.map((x) => x.node.raw));
+        // now we have the leaves and the values, so let's write it down to the DB.
+        const statesWrite = this.states.put(headerHash.raw, stateLeafs.raw);
+        const valuesWrite = this.values.transaction(() => {
+            for (const [hash, val] of values) {
+                this.values.put(hash.raw, val.raw);
+            }
+        });
+        try {
+            await Promise.all([valuesWrite, statesWrite]);
+        }
+        catch (e) {
+            logger.error `${e}`;
+            return Result.error(StateUpdateError.Commit, () => `Failed to commit state update: ${e}`);
+        }
+        return Result.ok(OK);
+    }
+    async updateAndSetState(headerHash, state, update) {
+        const updatedValues = serializeStateUpdate(this.spec, this.blake2b, update);
+        // and finally we insert new values and store leaves in the DB.
+        const res = await this.updateAndCommit(headerHash, state.backend.leafs, updatedValues);
+        if (res.isOk) {
+            // update the internal backend with new leaves.
+            state.updateBackend(LeafDb.fromLeaves(state.backend.leafs, state.backend.db));
+        }
+        return res;
+    }
+    async getStateRoot(state) {
+        return state.backend.getStateRoot(this.blake2b);
+    }
+    getState(root) {
+        const leafNodes = this.states.get(root.raw);
+        // we don't have that particular state.
+        if (leafNodes === undefined) {
+            return null;
+        }
+        const values = this.values;
+        const leafDbResult = LeafDb.fromLeavesBlob(BytesBlob.blobFrom(leafNodes), {
+            get(key) {
+                const val = values.get(key.raw);
+                if (val === undefined) {
+                    throw new Error(`Missing required value: ${key} in the DB`);
+                }
+                return val;
+            },
+        });
+        if (leafDbResult.isError) {
+            throw new Error(`Inconsistent DB. Invalid leaf nodes for ${root}: ${resultToString(leafDbResult)}`);
+        }
+        return SerializedState.new(this.spec, this.blake2b, leafDbResult.ok);
+    }
+    async close() {
+        await Promise.all([this.states.close(), this.values.close()]);
+    }
+}

package/packages/jam/database-lmdb/states.test.d.ts

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

package/packages/jam/database-lmdb/states.test.d.ts.map

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

package/packages/jam/database-lmdb/states.test.js

@@ -0,0 +1,203 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import { afterEach, before, beforeEach, describe, it } from "node:test";
+import { tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { SortedSet } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { MAX_VALUE } from "#@typeberry/pvm-interpreter/ops/math-consts.js";
+import { InMemoryState, LookupHistoryItem, PrivilegedServices, ServiceAccountInfo, tryAsLookupHistorySlots, tryAsPerCore, UpdateService, } from "#@typeberry/state";
+import { testState } from "#@typeberry/state/test.utils.js";
+import { StateEntries } from "#@typeberry/state-merkleization";
+import { InMemoryTrie, leafComparator } from "#@typeberry/trie";
+import { getBlake2bTrieHasher } from "#@typeberry/trie/hasher.js";
+import { Compatibility, deepEqual, GpVersion, OK, Result } from "#@typeberry/utils";
+import { LmdbRoot } from "./root.js";
+import { LmdbStates } from "./states.js";
+let blake2bTrieHasher;
+let blake2b;
+before(async () => {
+    blake2b = await Blake2b.createHasher();
+    blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
+});
+function createTempDir(suffix = "lmdb") {
+    return fs.mkdtempSync(`typeberry-${suffix}`);
+}
+describe("LMDB States database", () => {
+    let tmpDir = "";
+    beforeEach(() => {
+        tmpDir = createTempDir();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, {
+            recursive: true,
+        });
+    });
+    const headerHash = Bytes.zero(HASH_SIZE).asOpaque();
+    const spec = tinyChainSpec;
+    it("should import state and read state", async () => {
+        const root = new LmdbRoot(tmpDir);
+        const states = new LmdbStates(spec, blake2b, root);
+        try {
+            const emptyState = InMemoryState.empty(spec);
+            const serialized = StateEntries.serializeInMemory(spec, blake2b, emptyState);
+            const emptyRoot = serialized.getRootHash(blake2b);
+            // when
+            const res = await states.insertInitialState(headerHash, serialized);
+            deepEqual(res, Result.ok(OK));
+            const newState = states.getState(headerHash);
+            assert.ok(newState !== null);
+            const newRoot = await states.getStateRoot(newState);
+            assert.deepStrictEqual(`${newRoot}`, `${emptyRoot}`);
+            deepEqual(InMemoryState.copyFrom(spec, newState, new Map()), emptyState);
+        }
+        finally {
+            await states.close();
+            await root.close();
+        }
+    });
+    it("should update the state", async () => {
+        const root = new LmdbRoot(tmpDir);
+        const states = new LmdbStates(spec, blake2b, root);
+        try {
+            const state = InMemoryState.empty(spec);
+            await states.insertInitialState(headerHash, StateEntries.serializeInMemory(spec, blake2b, state));
+            const newState = states.getState(headerHash);
+            assert.ok(newState !== null);
+            const headerHash2 = Bytes.fill(HASH_SIZE, 2).asOpaque();
+            const lookupHistory = new LookupHistoryItem(Bytes.fill(HASH_SIZE, 0xff).asOpaque(), tryAsU32(5), tryAsLookupHistorySlots([]));
+            const stateUpdate = {
+                timeslot: tryAsTimeSlot(15),
+                privilegedServices: PrivilegedServices.create({
+                    manager: tryAsServiceId(1),
+                    assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(2)), spec),
+                    delegator: tryAsServiceId(3),
+                    registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? tryAsServiceId(4) : tryAsServiceId(MAX_VALUE),
+                    autoAccumulateServices: new Map(),
+                }),
+                updated: new Map([
+                    [
+                        tryAsServiceId(1),
+                        UpdateService.create({
+                            serviceInfo: ServiceAccountInfo.create({
+                                codeHash: Bytes.zero(HASH_SIZE).asOpaque(),
+                                balance: tryAsU64(1_000_000),
+                                accumulateMinGas: tryAsServiceGas(10_000),
+                                onTransferMinGas: tryAsServiceGas(5_000),
+                                storageUtilisationBytes: tryAsU64(1_000),
+                                gratisStorage: tryAsU64(0),
+                                storageUtilisationCount: tryAsU32(1),
+                                created: tryAsTimeSlot(0),
+                                lastAccumulation: tryAsTimeSlot(0),
+                                parentService: tryAsServiceId(0),
+                            }),
+                            lookupHistory,
+                        }),
+                    ],
+                ]),
+            };
+            // when
+            // in-memory state update
+            const res1 = state.applyUpdate(stateUpdate);
+            deepEqual(res1, Result.ok(OK));
+            // on-disk state update
+            const res2 = await states.updateAndSetState(headerHash2, newState, stateUpdate);
+            deepEqual(res2, Result.ok(OK));
+            const updatedState = states.getState(headerHash2);
+            assert.ok(updatedState !== null);
+            const updatedStateRoot = await states.getStateRoot(updatedState);
+            deepEqual(InMemoryState.copyFrom(spec, updatedState, new Map([
+                [
+                    tryAsServiceId(1),
+                    {
+                        storageKeys: [],
+                        preimages: [],
+                        lookupHistory: [{ hash: lookupHistory.hash, length: lookupHistory.length }],
+                    },
+                ],
+            ])), state);
+            assert.strictEqual(`${updatedStateRoot}`, `${StateEntries.serializeInMemory(spec, blake2b, state).getRootHash(blake2b)}`);
+        }
+        finally {
+            await states.close();
+            await root.close();
+        }
+    });
+    it("sorted set should be actual to trie", () => {
+        const data = [
+            [Bytes.fill(HASH_SIZE, 5), BytesBlob.blobFromString("five")],
+            [Bytes.fill(HASH_SIZE, 1), BytesBlob.blobFromString("one")],
+            [Bytes.fill(HASH_SIZE, 3), BytesBlob.blobFromString("three")],
+            [Bytes.fill(HASH_SIZE, 4), BytesBlob.blobFromString("four")],
+            [Bytes.fill(HASH_SIZE, 2), BytesBlob.blobFromString("two")],
+        ];
+        const trie = InMemoryTrie.empty(blake2bTrieHasher);
+        for (const [key, val] of data) {
+            trie.set(key.asOpaque(), val);
+        }
+        const set = SortedSet.fromArray(leafComparator, data.map(([key, value]) => {
+            return InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value);
+        }));
+        deepEqual(Array.from(set), Array.from(SortedSet.fromArray(leafComparator, Array.from(trie.nodes.leaves()))));
+    });
+    it("should import more complex state", async () => {
+        const root = new LmdbRoot(tmpDir);
+        const states = new LmdbStates(spec, blake2b, root);
+        try {
+            const initialState = testState();
+            const initialService = initialState.services.get(tryAsServiceId(0));
+            if (initialService === undefined) {
+                throw new Error("Expected service in test state!");
+            }
+            const serialized = StateEntries.serializeInMemory(spec, blake2b, initialState);
+            const initialRoot = serialized.getRootHash(blake2b);
+            // when
+            const res = await states.insertInitialState(headerHash, serialized);
+            deepEqual(res, Result.ok(OK));
+            const newState = states.getState(headerHash);
+            assert.ok(newState !== null);
+            const newRoot = await states.getStateRoot(newState);
+            assert.deepStrictEqual(`${newRoot}`, `${initialRoot}`);
+            deepEqual(InMemoryState.copyFrom(spec, newState, new Map([[initialService.serviceId, initialService.getEntries()]])), initialState);
+        }
+        finally {
+            await states.close();
+            await root.close();
+        }
+    });
+    it("should update more complex entries", async () => {
+        const root = new LmdbRoot(tmpDir);
+        const states = new LmdbStates(spec, blake2b, root);
+        try {
+            const state = testState();
+            const initialService = state.services.get(tryAsServiceId(0));
+            if (initialService === undefined) {
+                throw new Error("Expected service in test state!");
+            }
+            await states.insertInitialState(headerHash, StateEntries.serializeInMemory(spec, blake2b, state));
+            const newState = states.getState(headerHash);
+            assert.ok(newState !== null);
+            const headerHash2 = Bytes.fill(HASH_SIZE, 2).asOpaque();
+            // attempt to update all entries
+            const stateUpdate = Object.assign({}, state);
+            // when
+            // in-memory state update
+            const res1 = state.applyUpdate(stateUpdate);
+            deepEqual(res1, Result.ok(OK));
+            // on-disk state update
+            const res2 = await states.updateAndSetState(headerHash2, newState, stateUpdate);
+            deepEqual(res2, Result.ok(OK));
+            const updatedState = states.getState(headerHash2);
+            assert.ok(updatedState !== null);
+            const updatedStateRoot = await states.getStateRoot(updatedState);
+            deepEqual(InMemoryState.copyFrom(spec, updatedState, new Map([[initialService.serviceId, initialService.getEntries()]])), state);
+            assert.strictEqual(`${updatedStateRoot}`, `${StateEntries.serializeInMemory(spec, blake2b, state).getRootHash(blake2b)}`);
+        }
+        finally {
+            await states.close();
+            await root.close();
+        }
+    });
+});

package/packages/jam/fuzz-proto/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./server.js";
+export * as v1 from "./v1/index.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/fuzz-proto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/fuzz-proto/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC"}

package/packages/jam/fuzz-proto/index.js

@@ -0,0 +1,2 @@
+export * from "./server.js";
+export * as v1 from "./v1/index.js";

package/packages/jam/fuzz-proto/server.d.ts

@@ -0,0 +1,18 @@
+import type { BytesBlob } from "#@typeberry/bytes";
+/** A per-client handler of incoming socket messages. */
+export interface IpcHandler {
+    /** New data on the socket received. */
+    onSocketMessage(msg: Uint8Array): Promise<void>;
+    /** Socket closed or errored. */
+    onClose(reason: {
+        error?: Error;
+    }): void;
+}
+/** Sending data abstraction on a socket. */
+export interface IpcSender {
+    /** Write given data to the outgoing socket. */
+    send(data: BytesBlob): void;
+    /** Close the socket. */
+    close(): void;
+}
+//# sourceMappingURL=server.d.ts.map

package/packages/jam/fuzz-proto/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/fuzz-proto/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,wDAAwD;AACxD,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhD,gCAAgC;IAChC,OAAO,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,IAAI,CAAC;CAC1C;AAED,4CAA4C;AAC5C,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IAE5B,wBAAwB;IACxB,KAAK,IAAI,IAAI,CAAC;CACf"}

package/packages/jam/fuzz-proto/server.js

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