@typeberry/lib 0.5.1 → 0.5.2-03e1aed

package/packages/jam/node/export.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Block as BlockCodec } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { Encoder } from "#@typeberry/codec";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { Logger } from "#@typeberry/logger";
+import { LmdbWorkerConfig } from "#@typeberry/workers-api-node";
+import { getChainSpec, getDatabasePath } from "./common.js";
+export async function exportBlocks(jamNodeConfig, output, withRelPath) {
+    const logger = Logger.new(import.meta.filename, "export");
+    const concat = output.endsWith(".bin");
+    if (concat) {
+        logger.info `📤 Exporting blocks to ${output} (concatenated)`;
+        if (fs.existsSync(output)) {
+            fs.unlinkSync(output);
+        }
+    }
+    else {
+        logger.info `📤 Exporting blocks to ${output}`;
+        if (!fs.existsSync(output)) {
+            fs.mkdirSync(output, { recursive: true });
+        }
+    }
+    if (jamNodeConfig.node.databaseBasePath === undefined) {
+        logger.info `📖 Running with in-memory database. Nothing to do...`;
+        return;
+    }
+    const blake2b = await Blake2b.createHasher();
+    const chainSpec = getChainSpec(jamNodeConfig.node.flavor);
+    const { dbPath } = getDatabasePath(blake2b, jamNodeConfig.nodeName, jamNodeConfig.node.chainSpec.genesisHeader, withRelPath(jamNodeConfig.node.databaseBasePath));
+    const config = LmdbWorkerConfig.new({
+        nodeName: jamNodeConfig.nodeName,
+        chainSpec,
+        blake2b,
+        dbPath,
+        workerParams: undefined,
+    });
+    const rootDb = config.openDatabase();
+    const blocks = rootDb.getBlocksDb();
+    logger.info `📖 Gathering blocks...`;
+    const hashes = [];
+    let currentHash = blocks.getBestHeaderHash();
+    while (currentHash.isEqualTo(Bytes.zero(HASH_SIZE)) !== true) {
+        const header = blocks.getHeader(currentHash);
+        if (header !== null) {
+            hashes.push(currentHash);
+            currentHash = header.parentHeaderHash.materialize();
+        }
+        else {
+            break;
+        }
+    }
+    // reverse to export in chronological order
+    hashes.reverse();
+    logger.info `📕 ${hashes.length} blocks gathered.`;
+    for (let i = 0; i < hashes.length; i++) {
+        const header = blocks.getHeader(hashes[i]);
+        const extrinsic = blocks.getExtrinsic(hashes[i]);
+        if (header === null || extrinsic === null) {
+            throw new Error(`❌ Block ${currentHash} could not be read from the database.`);
+        }
+        const block = BlockCodec.create({
+            header: header.materialize(),
+            extrinsic: extrinsic.materialize(),
+        });
+        const encodedBlock = Encoder.encodeObject(BlockCodec.Codec, block, chainSpec);
+        if (concat) {
+            fs.appendFileSync(output, encodedBlock.raw);
+            logger.log `✅ Exported block ${i + 1}/${hashes.length}`;
+        }
+        else {
+            const filename = `${header.timeSlotIndex.materialize().toString().padStart(8, "0")}.bin`;
+            const filepath = path.join(output, filename);
+            fs.writeFileSync(filepath, encodedBlock.raw);
+            logger.log `✅ Exported block ${i + 1}/${hashes.length}: ${filename}`;
+        }
+    }
+    await rootDb.close();
+    logger.info `🫡 Export completed successfully: ${hashes.length} blocks exported to ${output}`;
+}

package/packages/jam/node/extensions.d.ts

@@ -0,0 +1,3 @@
+import * as ipc from "#@typeberry/ext-ipc";
+export declare function initializeExtensions(api: ipc.ExtensionApi): () => void;
+//# sourceMappingURL=extensions.d.ts.map

package/packages/jam/node/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oBAAoB,CAAC;AAE1C,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,CAAC,YAAY,cAKzD"}

package/packages/jam/node/extensions.js

@@ -0,0 +1,7 @@
+import * as ipc from "#@typeberry/ext-ipc";
+export function initializeExtensions(api) {
+    const closeIpc = ipc.startExtension(api);
+    return () => {
+        closeIpc();
+    };
+}

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

@@ -0,0 +1,8 @@
+export * from "./common.js";
+export * from "./export.js";
+export * from "./jam-config.js";
+export * from "./main.js";
+export * from "./main-fuzz.js";
+export * from "./metrics.js";
+export { importBlocks } from "./reader.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/packages/jam/node/index.js

@@ -0,0 +1,7 @@
+export * from "./common.js";
+export * from "./export.js";
+export * from "./jam-config.js";
+export * from "./main.js";
+export * from "./main-fuzz.js";
+export * from "./metrics.js";
+export { importBlocks } from "./reader.js";

package/packages/jam/node/jam-config.d.ts

@@ -0,0 +1,75 @@
+import { type HeaderHash, type TimeSlot, type ValidatorIndex } from "#@typeberry/block";
+import type { Bootnode, PvmBackend } from "#@typeberry/config";
+import type { NodeConfiguration } from "#@typeberry/config-node";
+import type { Ed25519SecretSeed, KeySeed } from "#@typeberry/crypto/key-derivation.js";
+import type { U16 } from "#@typeberry/numbers";
+export declare const DEFAULT_DEV_CONFIG: {
+    genesisPath: string;
+    timeSlot: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">;
+    validatorIndex: number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">;
+};
+/**
+ * Configuration object for jam node.
+ */
+export declare class JamConfig {
+    /** Whether we should be authoring blocks. */
+    readonly isAuthoring: boolean;
+    /** Node name. */
+    readonly nodeName: string;
+    /** Node starting configuration. */
+    readonly node: NodeConfiguration;
+    /** PVM execution engine. */
+    readonly pvmBackend: PvmBackend;
+    /** Developer specific configuration. */
+    readonly dev: DevConfig | null;
+    /** Networking options. */
+    readonly network: NetworkConfig | null;
+    /** Optional pre-genesis ancestry information. */
+    readonly ancestry: [HeaderHash, TimeSlot][];
+    /** Validator index for dev mode authorship. Use "all" to author as all validators. */
+    readonly devValidatorIndex: U16 | "all" | null;
+    static new({ isAuthoring, nodeName, nodeConfig, pvmBackend, devConfig, networkConfig, ancestry, devValidatorIndex, }: {
+        isAuthoring?: boolean;
+        nodeName: string;
+        nodeConfig: NodeConfiguration;
+        pvmBackend: PvmBackend;
+        devConfig?: DevConfig | null;
+        networkConfig?: NetworkConfig | null;
+        ancestry?: [HeaderHash, TimeSlot][];
+        /** Validator index for dev mode authorship. Use "all" to author as all validators. */
+        devValidatorIndex?: U16 | "all" | null;
+    }): JamConfig;
+    private constructor();
+}
+/** Validator key seeds in developer mode. */
+export type SeedDevConfig = {
+    /** Bandersnatch seed to derive key. */
+    bandersnatchSeed: KeySeed;
+    /** Bls seed to derive key. */
+    blsSeed: KeySeed;
+    /** Ed25519 seed to derive key. */
+    ed25519Seed: KeySeed;
+};
+/** Developer mode configuration. */
+export type DevConfig = {
+    /** Path to genesis state JSON description file. */
+    genesisPath: string;
+    /** Genesis time slot. */
+    timeSlot: TimeSlot;
+    /** Validator index for current node. */
+    validatorIndex: ValidatorIndex;
+    /** Validator seeds in development mode. */
+    seed?: SeedDevConfig;
+};
+/** Networking configuration. */
+export type NetworkConfig = {
+    /** Networking key seed. */
+    key: Ed25519SecretSeed;
+    /** Interface to bind networking socket to. */
+    host: string;
+    /** Port to bind networking socket to. */
+    port: number;
+    /** Bootnodes to connect to. */
+    bootnodes: Bootnode[];
+};
+//# sourceMappingURL=jam-config.d.ts.map

package/packages/jam/node/jam-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jam-config.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/jam-config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,QAAQ,EAGb,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AACtF,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAE9C,eAAO,MAAM,kBAAkB;;;;CAI9B,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS;IAkClB,6CAA6C;aAC7B,WAAW,EAAE,OAAO;IACpC,iBAAiB;aACD,QAAQ,EAAE,MAAM;IAChC,mCAAmC;aACnB,IAAI,EAAE,iBAAiB;IACvC,4BAA4B;aACZ,UAAU,EAAE,UAAU;IACtC,wCAAwC;aACxB,GAAG,EAAE,SAAS,GAAG,IAAI;IACrC,0BAA0B;aACV,OAAO,EAAE,aAAa,GAAG,IAAI;IAC7C,iDAAiD;aACjC,QAAQ,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE;IAClD,sFAAsF;aACtE,iBAAiB,EAAE,GAAG,GAAG,KAAK,GAAG,IAAI;IAhDvD,MAAM,CAAC,GAAG,CAAC,EACT,WAAW,EACX,QAAQ,EACR,UAAU,EACV,UAAU,EACV,SAAgB,EAChB,aAAoB,EACpB,QAAa,EACb,iBAAwB,GACzB,EAAE;QACD,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,iBAAiB,CAAC;QAC9B,UAAU,EAAE,UAAU,CAAC;QACvB,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;QAC7B,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;QACrC,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC;QACpC,sFAAsF;QACtF,iBAAiB,CAAC,EAAE,GAAG,GAAG,KAAK,GAAG,IAAI,CAAC;KACxC;IAaD,OAAO;CAkBR;AAED,6CAA6C;AAC7C,MAAM,MAAM,aAAa,GAAG;IAC1B,uCAAuC;IACvC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,8BAA8B;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,kCAAkC;IAClC,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,oCAAoC;AACpC,MAAM,MAAM,SAAS,GAAG;IAGtB,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB,yBAAyB;IACzB,QAAQ,EAAE,QAAQ,CAAC;IACnB,wCAAwC;IACxC,cAAc,EAAE,cAAc,CAAC;IAC/B,2CAA2C;IAC3C,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,gCAAgC;AAChC,MAAM,MAAM,aAAa,GAAG;IAC1B,2BAA2B;IAC3B,GAAG,EAAE,iBAAiB,CAAC;IACvB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,QAAQ,EAAE,CAAC;CACvB,CAAC"}

package/packages/jam/node/jam-config.js

@@ -0,0 +1,48 @@
+import { tryAsTimeSlot, tryAsValidatorIndex, } from "#@typeberry/block";
+export const DEFAULT_DEV_CONFIG = {
+    genesisPath: "",
+    timeSlot: tryAsTimeSlot(0),
+    validatorIndex: tryAsValidatorIndex(0),
+};
+/**
+ * Configuration object for jam node.
+ */
+export class JamConfig {
+    isAuthoring;
+    nodeName;
+    node;
+    pvmBackend;
+    dev;
+    network;
+    ancestry;
+    devValidatorIndex;
+    static new({ isAuthoring, nodeName, nodeConfig, pvmBackend, devConfig = null, networkConfig = null, ancestry = [], devValidatorIndex = null, }) {
+        return new JamConfig(isAuthoring ?? false, nodeName, nodeConfig, pvmBackend, devConfig, networkConfig, ancestry, devValidatorIndex);
+    }
+    constructor(
+    /** Whether we should be authoring blocks. */
+    isAuthoring, 
+    /** Node name. */
+    nodeName, 
+    /** Node starting configuration. */
+    node, 
+    /** PVM execution engine. */
+    pvmBackend, 
+    /** Developer specific configuration. */
+    dev, 
+    /** Networking options. */
+    network, 
+    /** Optional pre-genesis ancestry information. */
+    ancestry, 
+    /** Validator index for dev mode authorship. Use "all" to author as all validators. */
+    devValidatorIndex) {
+        this.isAuthoring = isAuthoring;
+        this.nodeName = nodeName;
+        this.node = node;
+        this.pvmBackend = pvmBackend;
+        this.dev = dev;
+        this.network = network;
+        this.ancestry = ancestry;
+        this.devValidatorIndex = devValidatorIndex;
+    }
+}

package/packages/jam/node/main-fuzz.d.ts

@@ -0,0 +1,16 @@
+import { type FuzzVersion } from "#@typeberry/ext-ipc";
+import { v1 as fuzzV1 } from "#@typeberry/fuzz-proto";
+import type { JamConfig } from "./jam-config.js";
+export type FuzzConfig = {
+    version: FuzzVersion;
+    jamNodeConfig: JamConfig;
+    socket: string | null;
+    initGenesisFromAncestry: boolean;
+};
+export declare function getFuzzDetails(): {
+    nodeName: string;
+    nodeVersion: fuzzV1.Version;
+    gpVersion: fuzzV1.Version;
+};
+export declare function mainFuzz(fuzzConfig: FuzzConfig, withRelPath: (v: string) => string): Promise<() => void>;
+//# sourceMappingURL=main-fuzz.d.ts.map

package/packages/jam/node/main-fuzz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-fuzz.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main-fuzz.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAMrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB,aAAa,EAAE,SAAS,CAAC;IACzB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,uBAAuB,EAAE,OAAO,CAAC;CAClC,CAAC;AAIF,wBAAgB,cAAc;;;;EAM7B;AAED,wBAAsB,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,uBAoExF"}

package/packages/jam/node/main-fuzz.js

@@ -0,0 +1,76 @@
+import { Header } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { Encoder } from "#@typeberry/codec";
+import { PvmBackend } from "#@typeberry/config";
+import { startFuzzTarget } from "#@typeberry/ext-ipc";
+import { v1 as fuzzV1 } from "#@typeberry/fuzz-proto";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { Logger } from "#@typeberry/logger";
+import { CURRENT_VERSION, Result } from "#@typeberry/utils";
+import { getChainSpec } from "./common.js";
+import { mainImporter } from "./main-importer.js";
+import packageJson from "./package.json" with { type: "json" };
+const logger = Logger.new(import.meta.filename, "fuzztarget");
+export function getFuzzDetails() {
+    return {
+        nodeName: "@typeberry/jam",
+        nodeVersion: fuzzV1.Version.tryFromString(packageJson.version),
+        gpVersion: fuzzV1.Version.tryFromString(CURRENT_VERSION.split("-")[0]),
+    };
+}
+export async function mainFuzz(fuzzConfig, withRelPath) {
+    logger.info `💨 Fuzzer V${fuzzConfig.version} starting up.`;
+    logger.info `🖥️ PVM Backend: ${PvmBackend[fuzzConfig.jamNodeConfig.pvmBackend]}.`;
+    const { jamNodeConfig: config } = fuzzConfig;
+    let runningNode = null;
+    const chainSpec = getChainSpec(config.node.flavor);
+    const closeFuzzTarget = startFuzzTarget(fuzzConfig.version, fuzzConfig.socket, {
+        ...getFuzzDetails(),
+        chainSpec,
+        importBlock: async (blockView) => {
+            if (runningNode === null) {
+                return Result.error("node not running", () => "Fuzzer: node not running when importing block");
+            }
+            const importResult = await runningNode.importBlock(blockView);
+            return importResult;
+        },
+        getBestStateRootHash: async () => {
+            if (runningNode === null) {
+                return Bytes.zero(HASH_SIZE).asOpaque();
+            }
+            return runningNode.getBestStateRootHash();
+        },
+        getPostSerializedState: async (hash) => {
+            if (runningNode === null) {
+                return null;
+            }
+            return runningNode.getStateEntries(hash);
+        },
+        resetState: async (header, state, ancestry) => {
+            if (runningNode !== null) {
+                const finish = runningNode.close();
+                runningNode = null;
+                await finish;
+            }
+            // update the chainspec
+            const newNode = await mainImporter({
+                ...config,
+                node: {
+                    ...config.node,
+                    // use in-memory db
+                    databaseBasePath: undefined,
+                    chainSpec: {
+                        ...config.node.chainSpec,
+                        genesisHeader: Encoder.encodeObject(Header.Codec, header, chainSpec),
+                        genesisState: new Map(state),
+                    },
+                },
+                ancestry,
+                network: null,
+            }, withRelPath, { initGenesisFromAncestry: fuzzConfig.initGenesisFromAncestry });
+            runningNode = newNode;
+            return await newNode.getBestStateRootHash();
+        },
+    });
+    return closeFuzzTarget;
+}

package/packages/jam/node/main-fuzz.test.d.ts

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

package/packages/jam/node/main-fuzz.test.d.ts.map

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

package/packages/jam/node/main-fuzz.test.js

@@ -0,0 +1,26 @@
+import { describe, it } from "node:test";
+import { tryAsU8 } from "#@typeberry/numbers";
+import { CURRENT_VERSION, deepEqual } from "#@typeberry/utils";
+//eslint-disable-next-line import/no-relative-packages
+import pkg from "../../../package.json" with { type: "json" };
+import { getFuzzDetails } from "./main-fuzz.js";
+describe("fuzzing config", () => {
+    it("should create config from current version", () => {
+        const [m, i, p] = pkg.version.split(".").map((x) => Number.parseInt(x, 10));
+        const [gpM, gpI, gpP] = CURRENT_VERSION.split(".").map((x) => Number.parseInt(x, 10));
+        const fuzzDetails = getFuzzDetails();
+        deepEqual(fuzzDetails, {
+            nodeName: "@typeberry/jam",
+            nodeVersion: {
+                major: tryAsU8(m),
+                minor: tryAsU8(i),
+                patch: tryAsU8(p),
+            },
+            gpVersion: {
+                major: tryAsU8(gpM),
+                minor: tryAsU8(gpI),
+                patch: tryAsU8(gpP),
+            },
+        }, { ignore: ["nodeVersion.patch"] });
+    });
+});

package/packages/jam/node/main-importer.d.ts

@@ -0,0 +1,7 @@
+import type { JamConfig } from "./jam-config.js";
+import type { NodeApi } from "./main.js";
+export type ImporterOptions = {
+    initGenesisFromAncestry?: boolean;
+};
+export declare function mainImporter(config: JamConfig, withRelPath: (v: string) => string, options?: ImporterOptions): Promise<NodeApi>;
+//# sourceMappingURL=main-importer.d.ts.map

package/packages/jam/node/main-importer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-importer.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main-importer.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKzC,MAAM,MAAM,eAAe,GAAG;IAC5B,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF,wBAAsB,YAAY,CAChC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAClC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CA4ElB"}

package/packages/jam/node/main-importer.js

@@ -0,0 +1,74 @@
+import { Bytes } from "#@typeberry/bytes";
+import { PvmBackend } from "#@typeberry/config";
+import { initWasm } from "#@typeberry/crypto";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { createImporter } from "#@typeberry/importer";
+import { CURRENT_SUITE, CURRENT_VERSION, Result, resultToString } from "#@typeberry/utils";
+import { InMemWorkerConfig, LmdbWorkerConfig } from "#@typeberry/workers-api-node";
+import { getChainSpec, getDatabasePath, initializeDatabase, logger } from "./common.js";
+import packageJson from "./package.json" with { type: "json" };
+const zeroHash = Bytes.zero(HASH_SIZE).asOpaque();
+export async function mainImporter(config, withRelPath, options = {}) {
+    await initWasm();
+    logger.info `🫐 Typeberry ${packageJson.version}. GP: ${CURRENT_VERSION} (${CURRENT_SUITE})`;
+    logger.info `🎸 Starting importer: ${config.nodeName}.`;
+    logger.info `🖥️ PVM Backend: ${PvmBackend[config.pvmBackend]}.`;
+    const chainSpec = getChainSpec(config.node.flavor);
+    const blake2b = await Blake2b.createHasher();
+    const nodeName = config.nodeName;
+    const { dbPath, genesisHeaderHash } = getDatabasePath(blake2b, config.nodeName, config.node.chainSpec.genesisHeader, withRelPath(config.node.databaseBasePath ?? "<in-memory>"));
+    const workerConfig = config.node.databaseBasePath === undefined
+        ? InMemWorkerConfig.new({
+            nodeName,
+            chainSpec,
+            blake2b,
+            workerParams: {
+                pvm: config.pvmBackend,
+            },
+        })
+        : LmdbWorkerConfig.new({
+            nodeName,
+            chainSpec,
+            blake2b,
+            dbPath,
+            workerParams: {
+                pvm: config.pvmBackend,
+            },
+        });
+    // Initialize the database with genesis state and block if there isn't one.
+    logger.info `🛢️ Opening database at ${dbPath}`;
+    const rootDb = workerConfig.openDatabase({ readonly: false });
+    await initializeDatabase(chainSpec, blake2b, genesisHeaderHash, rootDb, config.node.chainSpec, config.ancestry, {
+        initGenesisFromAncestry: options.initGenesisFromAncestry,
+    });
+    await rootDb.close();
+    const { db, importer } = await createImporter(workerConfig, {
+        initGenesisFromAncestry: options.initGenesisFromAncestry,
+    });
+    await importer.prepareForNextEpoch();
+    const api = {
+        chainSpec,
+        async importBlock(block) {
+            const res = await importer.importBlockWithStateRoot(block);
+            if (res.isOk) {
+                return res;
+            }
+            const errMsg = resultToString(res);
+            return Result.error(errMsg, () => errMsg);
+        },
+        async getStateEntries(hash) {
+            return importer.getStateEntries(hash);
+        },
+        async getBestStateRootHash() {
+            return importer.getBestStateRootHash() ?? zeroHash;
+        },
+        async close() {
+            logger.log `[main] ⏳ Closing importer`;
+            await importer.close();
+            logger.log `[main] 🛢️ Closing database`;
+            await db.close();
+            logger.info `[main] ✅ Done.`;
+        },
+    };
+    return api;
+}

package/packages/jam/node/main.d.ts

@@ -0,0 +1,15 @@
+import type { BlockView, HeaderHash, StateRootHash } from "#@typeberry/block";
+import { type ChainSpec } from "#@typeberry/config";
+import type { StateEntries } from "#@typeberry/state-merkleization";
+import type { Telemetry } from "#@typeberry/telemetry";
+import { Result } from "#@typeberry/utils";
+import type { JamConfig } from "./jam-config.js";
+export type NodeApi = {
+    chainSpec: ChainSpec;
+    getStateEntries(hash: HeaderHash): Promise<StateEntries | null>;
+    importBlock(block: BlockView): Promise<Result<StateRootHash, string>>;
+    getBestStateRootHash(): Promise<StateRootHash>;
+    close(): Promise<void>;
+};
+export declare function main(config: JamConfig, withRelPath: (v: string) => string, telemetry: Telemetry | null): Promise<NodeApi>;
+//# sourceMappingURL=main.d.ts.map

package/packages/jam/node/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAc,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,mBAAmB,CAAC;AAe/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAkC,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAK1E,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,iBAAiB,CAAC;AAYhE,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAChE,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC;IACtE,oBAAoB,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,wBAAsB,IAAI,CACxB,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAClC,SAAS,EAAE,SAAS,GAAG,IAAI,GAC1B,OAAO,CAAC,OAAO,CAAC,CAsJlB"}