@typeberry/lib 0.10.0-9e3af22 → 0.11.0-411c828

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()]),
-        };
-    }
-}
+// Re-exported so the fuzz target can open one keyspace per run and reuse it
+// across resets.
+export { FjallRoot, FjallValuesSession };
 /** Worker config for node.js, backed by a shared fjall engine. */
 export class FjallWorkerConfig {
     nodeName;
@@ -85,8 +17,9 @@ export class FjallWorkerConfig {
     ports;
     ephemeral;
     cacheSizeBytes;
-    static new({ nodeName, chainSpec, workerParams, dbPath, blake2b, ports = new Map(), ephemeral = false, cacheSizeBytes, }) {
-        return new FjallWorkerConfig(nodeName, chainSpec, workerParams, dbPath, blake2b, ports, ephemeral, cacheSizeBytes);
+    sharedFjallKeyspace;
+    static new({ nodeName, chainSpec, workerParams, dbPath, blake2b, ports = new Map(), ephemeral = false, cacheSizeBytes, sharedFjallKeyspace, }) {
+        return new FjallWorkerConfig(nodeName, chainSpec, workerParams, dbPath, blake2b, ports, ephemeral, cacheSizeBytes, sharedFjallKeyspace);
     }
     /** Restore node config from a transferable config object. */
     static async fromTransferable(decodeParams, config) {
@@ -106,7 +39,7 @@ export class FjallWorkerConfig {
     }
     constructor(nodeName, chainSpec, workerParams, dbPath, blake2b, ports, 
     // Kept for the fuzz/importer path. When set, persist() is skipped.
-    ephemeral = false, cacheSizeBytes = undefined) {
+    ephemeral = false, cacheSizeBytes = undefined, sharedFjallKeyspace = undefined) {
         this.nodeName = nodeName;
         this.chainSpec = chainSpec;
         this.workerParams = workerParams;
@@ -115,13 +48,19 @@ export class FjallWorkerConfig {
         this.ports = ports;
         this.ephemeral = ephemeral;
         this.cacheSizeBytes = cacheSizeBytes;
+        this.sharedFjallKeyspace = sharedFjallKeyspace;
     }
     async openDatabase(options = { readonly: true }) {
-        const fjall = await FjallRoot.open(this.dbPath, {
-            readOnly: options.readonly,
-            ephemeral: this.ephemeral,
-            cacheSizeBytes: this.cacheSizeBytes,
-        });
+        if (this.sharedFjallKeyspace !== undefined && options.readonly) {
+            throw new Error("Cannot open a read-only fjall database from a shared writable keyspace.");
+        }
+        const fjall = this.sharedFjallKeyspace ??
+            (await FjallRoot.open(this.dbPath, {
+                readOnly: options.readonly,
+                ephemeral: this.ephemeral,
+                cacheSizeBytes: this.cacheSizeBytes,
+            }));
+        const ownsFjall = this.sharedFjallKeyspace === undefined;
         let blocks = null;
         let states = null;
         try {
@@ -131,7 +70,9 @@ export class FjallWorkerConfig {
             ]);
         }
         catch (e) {
-            await fjall.close();
+            if (ownsFjall) {
+                await fjall.close();
+            }
             throw e;
         }
         return {
@@ -150,7 +91,9 @@ export class FjallWorkerConfig {
             close: async () => {
                 blocks = null;
                 states = null;
-                await fjall.close();
+                if (ownsFjall) {
+                    await fjall.close();
+                }
             },
         };
     }
@@ -181,12 +124,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 +170,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 +192,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, sharedFjallKeyspace, }) {
         // 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 });
+        // keyspace is given (fuzz reset reuse) we wrap it instead of opening a new one.
+        const states = sharedFjallKeyspace !== undefined
+            ? await FjallHybridSerializedStates.fromRoot(chainSpec, blake2b, sharedFjallKeyspace)
+            : 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,15 @@
 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 { FjallRoot } from "#@typeberry/database-fjall";
 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();
@@ -88,40 +57,90 @@ describe("FjallWorkerConfig transfer list", () => {
             fs.rmSync(dbPath, { recursive: true, force: true });
         }
     });
+    it("can borrow a shared fjall root without closing it", async () => {
+        const blake2b = await Blake2b.createHasher();
+        const dbPath = fs.mkdtempSync("typeberry-fjall-worker-shared-");
+        const root = await FjallRoot.open(dbPath, { ephemeral: true });
+        const config = FjallWorkerConfig.new({
+            nodeName: "node",
+            chainSpec: spec,
+            workerParams: undefined,
+            dbPath,
+            blake2b,
+            sharedFjallKeyspace: root,
+        });
+        try {
+            const db = await config.openDatabase({ readonly: false });
+            await db.close();
+            await root.deletePartition("headers");
+            const headers = await root.writablePartition("headers");
+            assert.strictEqual(headers.get(Bytes.zero(HASH_SIZE).raw), null);
+        }
+        finally {
+            await root.close();
+            fs.rmSync(dbPath, { recursive: true, force: true });
+        }
+    });
 });
 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 });
+        }
+    });
+    it("can borrow a shared fjall root for the values store", async () => {
+        const blake2b = await Blake2b.createHasher();
+        const dbPath = fs.mkdtempSync("typeberry-hybrid-fjall-shared-");
+        const root = await FjallRoot.open(dbPath, { ephemeral: true });
+        try {
+            const config = await HybridWorkerConfig.new({
+                nodeName: "node",
+                chainSpec: spec,
+                workerParams: undefined,
+                blake2b,
+                dbPath,
+                ephemeral: true,
+                sharedFjallKeyspace: root,
+            });
+            const db = await config.openDatabase({ readonly: false });
+            const states = db.getStatesDb();
+            try {
+                assert.notStrictEqual(db.getBlocksDb(), undefined);
+                assert.notStrictEqual(states, undefined);
+            }
+            finally {
+                await states.close();
+                await db.close();
+            }
+            await root.deletePartition("values");
+        }
+        finally {
+            await root.close();
+            fs.rmSync(dbPath, { recursive: true, force: true });
+        }
+    });
 });

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"}