@typeberry/lib 0.10.0 → 0.11.0-829b7ea

package/packages/workers/api-node/config.js

@@ -2,79 +2,11 @@ import { Decoder, Encoder } from "#@typeberry/codec";
 import { ChainSpec } from "#@typeberry/config";
 import { InMemoryBlocks, InMemorySerializedStates, } from "#@typeberry/database";
 import { FjallBlocks, HybridSerializedStates as FjallHybridSerializedStates, FjallRoot, FjallStates, FjallValuesSession, } from "#@typeberry/database-fjall";
-import { LmdbBlocks, HybridSerializedStates as LmdbHybridSerializedStates, LmdbRoot, LmdbStates, } from "#@typeberry/database-lmdb";
 import { Blake2b } from "#@typeberry/hash";
 import { ThreadPort } from "./port.js";
 // Re-exported so the fuzz target can open one values session per run and reuse
 // it across resets (see `HybridWorkerConfig` / `mainFuzz`).
 export { FjallValuesSession };
-/**
- * Worker config for node.js, backed by the LMDB database.
- *
- * @deprecated lmdb is retained as an explicit fallback. Use `FjallWorkerConfig` for regular nodes.
- */
-export class LmdbWorkerConfig {
-    nodeName;
-    chainSpec;
-    workerParams;
-    dbPath;
-    blake2b;
-    ports;
-    ephemeral;
-    static new({ nodeName, chainSpec, workerParams, dbPath, blake2b, ports = new Map(), ephemeral = false, }) {
-        return new LmdbWorkerConfig(nodeName, chainSpec, workerParams, dbPath, blake2b, ports, ephemeral);
-    }
-    /** Restore node config from a transferable config object. */
-    static async fromTransferable(decodeParams, config) {
-        if (config.databaseBackend !== "lmdb") {
-            throw new Error(`Expected lmdb worker config, got ${config.databaseBackend}.`);
-        }
-        const { blake2b, chainSpec, workerParams, ports } = await decodeTransferableConfig(decodeParams, config);
-        return LmdbWorkerConfig.new({
-            nodeName: config.nodeName,
-            chainSpec,
-            workerParams,
-            dbPath: config.dbPath,
-            blake2b,
-            ports,
-        });
-    }
-    constructor(nodeName, chainSpec, workerParams, dbPath, blake2b, ports, 
-    // When set, the underlying database skips fsync. Only safe for throwaway
-    // databases (the fuzz target wipes on reset). Not transferred to worker
-    // threads, so the durable main node path always gets the default.
-    ephemeral = false) {
-        this.nodeName = nodeName;
-        this.chainSpec = chainSpec;
-        this.workerParams = workerParams;
-        this.dbPath = dbPath;
-        this.blake2b = blake2b;
-        this.ports = ports;
-        this.ephemeral = ephemeral;
-    }
-    async openDatabase(options = { readonly: true }) {
-        const lmdb = LmdbRoot.new(this.dbPath, {
-            readOnly: options.readonly,
-            ephemeral: this.ephemeral,
-        });
-        return {
-            getBlocksDb: () => LmdbBlocks.new(this.chainSpec, lmdb),
-            getStatesDb: () => LmdbStates.new(this.chainSpec, this.blake2b, lmdb),
-            close: async () => await lmdb.close(),
-        };
-    }
-    /** Convert this config into a thread-transferable object. */
-    intoTransferable(paramsCodec) {
-        return {
-            databaseBackend: "lmdb",
-            nodeName: this.nodeName,
-            chainSpec: this.chainSpec,
-            workerParams: Encoder.encodeObject(paramsCodec, this.workerParams, this.chainSpec).raw,
-            dbPath: this.dbPath,
-            workerPorts: Array.from(this.ports.entries()).map(([name, port]) => [name, port.intoTransferable()]),
-        };
-    }
-}
 /** Worker config for node.js, backed by a shared fjall engine. */
 export class FjallWorkerConfig {
     nodeName;
@@ -181,12 +113,7 @@ async function decodeTransferableConfig(decodeParams, config) {
 }
 /** Restore a persistent worker config from its transferable form. */
 export async function persistentConfigFromTransferable(decodeParams, config) {
-    switch (config.databaseBackend) {
-        case "lmdb":
-            return LmdbWorkerConfig.fromTransferable(decodeParams, config);
-        case "fjall":
-            return FjallWorkerConfig.fromTransferable(decodeParams, config);
-    }
+    return FjallWorkerConfig.fromTransferable(decodeParams, config);
 }
 /**
  * Collect the transferable objects (communication ports) embedded in a config.
@@ -232,8 +159,7 @@ export class InMemWorkerConfig {
 }
 /**
  * Hybrid worker config for the fuzz target: in-memory blocks and leaf sets,
- * but large values persisted to disk. The `backend` picks where the values go
- * (lmdb or fjall).
+ * but large values persisted to disk via fjall.
  *
  * fjall opens its keyspace asynchronously, that is why `new` here is async.
  *
@@ -255,14 +181,12 @@ export class HybridWorkerConfig {
     ephemeral;
     compression;
     states;
-    static async new({ nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral = false, compression = true, backend = "lmdb", sharedFjallSession, }) {
+    static async new({ nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral = false, compression = true, sharedFjallSession, }) {
         // The values store is created once here and shared across reopen. When a
         // session is given (fuzz reset reuse) we wrap it instead of opening a new one.
-        const states = backend === "fjall"
-            ? sharedFjallSession !== undefined
-                ? FjallHybridSerializedStates.fromSession(chainSpec, blake2b, sharedFjallSession)
-                : await FjallHybridSerializedStates.new({ spec: chainSpec, blake2b, dbPath, ephemeral })
-            : LmdbHybridSerializedStates.new({ spec: chainSpec, blake2b, dbPath, ephemeral, compression, readOnly: false });
+        const states = sharedFjallSession !== undefined
+            ? FjallHybridSerializedStates.fromSession(chainSpec, blake2b, sharedFjallSession)
+            : await FjallHybridSerializedStates.new({ spec: chainSpec, blake2b, dbPath, ephemeral });
         return new HybridWorkerConfig(nodeName, chainSpec, workerParams, blake2b, dbPath, ephemeral, compression, states);
     }
     blocks;

package/packages/workers/api-node/config.test.js

@@ -1,46 +1,14 @@
 import assert from "node:assert";
 import * as fs from "node:fs";
 import { describe, it } from "node:test";
-import { MessageChannel } from "node:worker_threads";
 import { Bytes } from "#@typeberry/bytes";
 import { codec } from "#@typeberry/codec";
 import { tinyChainSpec } from "#@typeberry/config";
 import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
 import { tryAsU32 } from "#@typeberry/numbers";
-import { configTransferList, FjallWorkerConfig, HybridWorkerConfig, LmdbWorkerConfig } from "./config.js";
+import { configTransferList, FjallWorkerConfig, HybridWorkerConfig } from "./config.js";
 import { ThreadPort } from "./port.js";
 const spec = tinyChainSpec;
-describe("LmdbWorkerConfig transfer list", () => {
-    it("surfaces embedded worker ports so they can be transferred", async () => {
-        const blake2b = await Blake2b.createHasher();
-        const [portA, portB] = ThreadPort.pair(spec);
-        const config = LmdbWorkerConfig.new({
-            nodeName: "node",
-            chainSpec: spec,
-            workerParams: tryAsU32(7),
-            dbPath: "db",
-            blake2b,
-            ports: new Map([["authorship-network", portA]]),
-        });
-        const transferable = config.intoTransferable(codec.varU32);
-        const transferList = configTransferList(transferable);
-        // the single embedded comms port must be reported for transfer
-        assert.strictEqual(transferList.length, 1);
-        const sink = new MessageChannel();
-        try {
-            // reproduces the bug: a config carrying a port cannot be cloned without
-            // listing that port in the transfer list.
-            assert.throws(() => sink.port1.postMessage(transferable, []), /transfer/i);
-            // with the ports surfaced, posting succeeds.
-            assert.doesNotThrow(() => sink.port1.postMessage(transferable, transferList));
-        }
-        finally {
-            sink.port1.close();
-            sink.port2.close();
-            portB.close();
-        }
-    });
-});
 describe("FjallWorkerConfig transfer list", () => {
     it("surfaces embedded worker ports and marks the backend", async () => {
         const blake2b = await Blake2b.createHasher();
@@ -90,38 +58,33 @@ describe("FjallWorkerConfig transfer list", () => {
     });
 });
 describe("HybridWorkerConfig", () => {
-    // Both persistent backends must construct asynchronously and hand out a
-    // working db. fjall is the experimental backend we want to benchmark.
-    for (const backend of ["lmdb", "fjall"]) {
-        it(`constructs and opens a ${backend}-backed hybrid db`, async () => {
-            const blake2b = await Blake2b.createHasher();
-            const dbPath = fs.mkdtempSync(`typeberry-hybrid-${backend}-`);
+    it("constructs and opens a fjall-backed hybrid db", async () => {
+        const blake2b = await Blake2b.createHasher();
+        const dbPath = fs.mkdtempSync("typeberry-hybrid-fjall-");
+        try {
+            const config = await HybridWorkerConfig.new({
+                nodeName: "node",
+                chainSpec: spec,
+                workerParams: undefined,
+                blake2b,
+                dbPath,
+                ephemeral: true,
+            });
+            const db = await config.openDatabase({ readonly: false });
+            const states = db.getStatesDb();
             try {
-                const config = await HybridWorkerConfig.new({
-                    nodeName: "node",
-                    chainSpec: spec,
-                    workerParams: undefined,
-                    blake2b,
-                    dbPath,
-                    ephemeral: true,
-                    backend,
-                });
-                const db = await config.openDatabase({ readonly: false });
-                const states = db.getStatesDb();
-                try {
-                    assert.notStrictEqual(db.getBlocksDb(), undefined);
-                    assert.notStrictEqual(states, undefined);
-                }
-                finally {
-                    // The values store owns the on-disk resources (the no-op db.close()
-                    // does not), so close it explicitly to release the fjall keyspace.
-                    await states.close();
-                    await db.close();
-                }
+                assert.notStrictEqual(db.getBlocksDb(), undefined);
+                assert.notStrictEqual(states, undefined);
             }
             finally {
-                fs.rmSync(dbPath, { recursive: true, force: true });
+                // The values store owns the on-disk resources (the no-op db.close()
+                // does not), so close it explicitly to release the fjall keyspace.
+                await states.close();
+                await db.close();
             }
-        });
-    }
+        }
+        finally {
+            fs.rmSync(dbPath, { recursive: true, force: true });
+        }
+    });
 });

package/packages/workers/importer/main.d.ts

@@ -6,6 +6,8 @@ import type { ImporterConfig, ImporterInternal } from "./protocol.js";
 export type Config = WorkerConfig<ImporterConfig, BlocksDb, StatesDb<SerializedState<LeafDb>>>;
 export type CreateImporterOptions = {
     initGenesisFromAncestry?: boolean;
+    /** Provide an already-open database to reuse instead of opening a new one. */
+    db?: Awaited<ReturnType<Config["openDatabase"]>>;
 };
 export declare function createImporter(config: Config, options?: CreateImporterOptions): Promise<{
     importer: Importer;

package/packages/workers/importer/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/importer/main.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMtE,MAAM,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,EAAE,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAE/F,MAAM,MAAM,qBAAqB,GAAG;IAClC,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC;IACT,QAAQ,EAAE,QAAQ,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CACjD,CAAC,CA8BD;AAED;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,iBAwCjE"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/importer/main.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMtE,MAAM,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,EAAE,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAE/F,MAAM,MAAM,qBAAqB,GAAG;IAClC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,8EAA8E;IAC9E,EAAE,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CAClD,CAAC;AAEF,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC;IACT,QAAQ,EAAE,QAAQ,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CACjD,CAAC,CA8BD;AAED;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,iBAwCjE"}

package/packages/workers/importer/main.js

@@ -10,7 +10,7 @@ const keccakHasher = keccak.KeccakHasher.create();
 const blake2b = Blake2b.createHasher();
 export async function createImporter(config, options = {}) {
     const chainSpec = config.chainSpec;
-    const db = await config.openDatabase({ readonly: false });
+    const db = options.db ?? (await config.openDatabase({ readonly: false }));
     const pvm = config.workerParams.pvm;
     const blocks = db.getBlocksDb();
     const states = db.getStatesDb();

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

@@ -1,24 +0,0 @@
-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;
-    static new(chainSpec: ChainSpec, root: LmdbRoot): LmdbBlocks;
-    private constructor();
-    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;
-    markUnused(hash: HeaderHash): void;
-    close(): Promise<void>;
-}
-//# sourceMappingURL=blocks.d.ts.map

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

@@ -1 +0,0 @@
-{"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;IAUvC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAVvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IAEvC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ;IAI/C,OAAO;IAeD,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;IAQpD,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAM5B,KAAK;CAGZ"}

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

@@ -1,82 +0,0 @@
-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;
-    static new(chainSpec, root) {
-        return new LmdbBlocks(chainSpec, root);
-    }
-    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);
-    }
-    markUnused(hash) {
-        this.headers.removeSync(hash.raw);
-        this.extrinsics.removeSync(hash.raw);
-        this.postStateRoots.removeSync(hash.raw);
-    }
-    async close() {
-        await Promise.all([this.headers.close(), this.extrinsics.close(), this.postStateRoots.close()]);
-    }
-}

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

@@ -1,56 +0,0 @@
-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 { SerializedState, type StateEntries } from "#@typeberry/state-merkleization";
-import { OK, Result } from "#@typeberry/utils";
-/**
- * Hybrid serialized-states db.
- *
- * States (leafs) are kept in-memory, but large values are persisted to lmdb.
- * Reads go straight to lmdb, which keeps its own page cache.
- * NOTE: this DB is designed for long fuzzing and to be used with pruning to
- * keep the heap usage bounded.
- *
- * Values that no longer belong to any surviving state are removed from lmdb,
- * decided by in-memory refcounting (`ValueRefs`) driven by the importer's
- * finality signal. Counts are not persisted: this db cannot resume from disk
- * anyway (the leaf sets live in memory), so values left over by a previous
- * run are never collected.
- */
-export declare class HybridSerializedStates implements StatesDb<SerializedState<LeafDb>>, InitStatesDb<StateEntries> {
-    private readonly spec;
-    private readonly blake2b;
-    private readonly root;
-    private readonly inMemStates;
-    private readonly lmdbValues;
-    private readonly valuesDb;
-    private readonly refsStore;
-    private readonly refs;
-    private pendingCleanup;
-    static new({ spec, blake2b, dbPath, readOnly, ephemeral, compression, }: {
-        spec: ChainSpec;
-        blake2b: Blake2b;
-        dbPath: string;
-        readOnly?: boolean;
-        ephemeral?: boolean;
-        compression?: boolean;
-    }): HybridSerializedStates;
-    private constructor();
-    insertInitialState(headerHash: HeaderHash, entries: StateEntries): Promise<Result<OK, StateUpdateError>>;
-    updateAndSetState(header: HeaderHash, state: SerializedState<LeafDb>, update: Partial<State & ServicesUpdate>): Promise<Result<OK, StateUpdateError>>;
-    getStateRoot(state: SerializedState<LeafDb>): Promise<StateRootHash>;
-    getState(header: HeaderHash): SerializedState<LeafDb> | null;
-    commitFinalized(headers: HeaderHash[]): void;
-    markUnused(header: HeaderHash): void;
-    /** Apply a refcounting update and remove values that lost their last reference. */
-    private applyRefs;
-    diskSizeInBytes(): number | null;
-    close(): Promise<void>;
-    /** Write new large values to LMDB in one transaction. */
-    private writeValues;
-    /** Read a value from LMDB. */
-    private readValue;
-}
-//# sourceMappingURL=hybrid-states.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hybrid-states.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database-lmdb/hybrid-states.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EACL,KAAK,YAAY,EAEjB,MAAM,EACN,KAAK,QAAQ,EACb,gBAAgB,EAKjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EACL,eAAe,EACf,KAAK,YAAY,EAGlB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAK9C;;;;;;;;;;;;;GAaG;AACH,qBAAa,sBAAuB,YAAW,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC;IA8BxG,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IA/BvB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyE;IACrG,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IAEnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAC1D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAiC;IAEtD,OAAO,CAAC,cAAc,CAAuC;IAE7D,MAAM,CAAC,GAAG,CAAC,EACT,IAAI,EACJ,OAAO,EACP,MAAM,EACN,QAAQ,EACR,SAAS,EACT,WAAW,GACZ,EAAE;QACD,IAAI,EAAE,SAAS,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;IAKD,OAAO;IASD,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAexG,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;IAmBlC,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAI1E,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,IAAI;IAS5D,eAAe,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI;IAI5C,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAOpC,mFAAmF;IACnF,OAAO,CAAC,SAAS;IAmBjB,eAAe,IAAI,MAAM,GAAG,IAAI;IAI1B,KAAK;IAMX,yDAAyD;YAC3C,WAAW;IAqBzB,8BAA8B;IAC9B,OAAO,CAAC,SAAS;CAOlB"}

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

@@ -1,149 +0,0 @@
-import { HashDictionary, SortedSet } from "#@typeberry/collections";
-import { InMemoryValueRefsStore, LeafDb, StateUpdateError, updateLeafs, ValueRefs, } from "#@typeberry/database";
-import { Logger } from "#@typeberry/logger";
-import { SerializedState, StateEntryUpdateAction, serializeStateUpdate, } from "#@typeberry/state-merkleization";
-import { leafComparator } from "#@typeberry/trie";
-import { OK, Result } from "#@typeberry/utils";
-import { LmdbRoot } from "./root.js";
-const logger = Logger.new(import.meta.filename, "db");
-/**
- * Hybrid serialized-states db.
- *
- * States (leafs) are kept in-memory, but large values are persisted to lmdb.
- * Reads go straight to lmdb, which keeps its own page cache.
- * NOTE: this DB is designed for long fuzzing and to be used with pruning to
- * keep the heap usage bounded.
- *
- * Values that no longer belong to any surviving state are removed from lmdb,
- * decided by in-memory refcounting (`ValueRefs`) driven by the importer's
- * finality signal. Counts are not persisted: this db cannot resume from disk
- * anyway (the leaf sets live in memory), so values left over by a previous
- * run are never collected.
- */
-export class HybridSerializedStates {
-    spec;
-    blake2b;
-    root;
-    inMemStates = HashDictionary.new();
-    lmdbValues;
-    // A single shared values accessor reused by every `LeafDb` we hand out.
-    valuesDb;
-    refsStore = new InMemoryValueRefsStore();
-    refs = new ValueRefs(this.refsStore);
-    // Queue of not-yet-committed value removals, awaited on close.
-    pendingCleanup = Promise.resolve();
-    static new({ spec, blake2b, dbPath, readOnly, ephemeral, compression, }) {
-        const root = LmdbRoot.new(dbPath, { readOnly, ephemeral, compression });
-        return new HybridSerializedStates(spec, blake2b, root);
-    }
-    constructor(spec, blake2b, root) {
-        this.spec = spec;
-        this.blake2b = blake2b;
-        this.root = root;
-        this.lmdbValues = this.root.subDb("values");
-        this.valuesDb = { get: (key) => this.readValue(key) };
-    }
-    async insertInitialState(headerHash, entries) {
-        const { values, leafs } = updateLeafs(SortedSet.fromArray(leafComparator, []), this.blake2b, Array.from(entries, (x) => [StateEntryUpdateAction.Insert, x[0], x[1]]));
-        const res = await this.writeValues(values);
-        if (res.isError) {
-            return res;
-        }
-        this.inMemStates.set(headerHash, leafs);
-        this.applyRefs(this.refs.onInitial(values.map((v) => v[0])));
-        return Result.ok(OK);
-    }
-    async updateAndSetState(header, state, update) {
-        const updatedValues = serializeStateUpdate(this.spec, this.blake2b, update);
-        // Clone the leaf set before mutating: the previous state keeps using its own.
-        const newLeafs = SortedSet.fromSortedArray(leafComparator, state.backend.leafs.array);
-        const { values, removed, leafs } = updateLeafs(newLeafs, this.blake2b, updatedValues);
-        const res = await this.writeValues(values);
-        if (res.isError) {
-            // Leave the caller's state untouched: its new leaves would reference
-            // values that never reached disk.
-            return res;
-        }
-        // Re-create the lookup with the shared values accessor only once the new
-        // values are durably written.
-        state.updateBackend(LeafDb.fromLeaves(leafs, this.valuesDb));
-        this.inMemStates.set(header, leafs);
-        this.applyRefs(this.refs.onImport(header, { inserted: values.map((v) => v[0]), removed }));
-        return Result.ok(OK);
-    }
-    async getStateRoot(state) {
-        return state.backend.getStateRoot(this.blake2b);
-    }
-    getState(header) {
-        const leafs = this.inMemStates.get(header);
-        if (leafs === undefined) {
-            return null;
-        }
-        const leafDb = LeafDb.fromLeaves(leafs, this.valuesDb);
-        return SerializedState.new(this.spec, this.blake2b, leafDb);
-    }
-    commitFinalized(headers) {
-        this.applyRefs(this.refs.commitFinalized(headers));
-    }
-    markUnused(header) {
-        // Release the speculative references first (a no-op for finalized states,
-        // whose deltas were already consumed by `commitFinalized`).
-        this.applyRefs(this.refs.releaseUnfinalized(header));
-        this.inMemStates.delete(header);
-    }
-    /** Apply a refcounting update and remove values that lost their last reference. */
-    applyRefs(update) {
-        this.refsStore.apply(update);
-        if (update.removeValues.length === 0) {
-            return;
-        }
-        // Queued, not awaited: a failed removal only leaks a value.
-        this.pendingCleanup = this.pendingCleanup
-            .then(() => this.lmdbValues.transaction(() => {
-            for (const v of update.removeValues) {
-                this.lmdbValues.remove(v.raw);
-            }
-        }))
-            .catch((e) => {
-            logger.error `Failed to remove unreferenced values: ${e}`;
-        });
-    }
-    diskSizeInBytes() {
-        return this.root.sizeInBytes();
-    }
-    async close() {
-        await this.pendingCleanup;
-        await this.lmdbValues.close();
-        await this.root.close();
-    }
-    /** Write new large values to LMDB in one transaction. */
-    async writeValues(values) {
-        if (values.length === 0) {
-            return Result.ok(OK);
-        }
-        try {
-            // Flush queued removals first: a pending cleanup might be about to delete
-            // a content hash we are re-inserting now. Writing behind it keeps the
-            // re-inserted value on disk (removals are only queued at refcount 0, so
-            // none can be queued for a value still referenced).
-            await this.pendingCleanup;
-            await this.lmdbValues.transaction(() => {
-                for (const [hash, val] of values) {
-                    this.lmdbValues.put(hash.raw, val.raw);
-                }
-            });
-        }
-        catch (e) {
-            return Result.error(StateUpdateError.Commit, () => `Failed to commit values: ${e}`);
-        }
-        return Result.ok(OK);
-    }
-    /** Read a value from LMDB. */
-    readValue(key) {
-        const val = this.lmdbValues.get(key.raw);
-        if (val === undefined) {
-            throw new Error(`Missing value at key: ${key}`);
-        }
-        return val;
-    }
-}

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

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

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

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