@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/config-node/jip-chain-spec.js

@@ -0,0 +1,65 @@
+import { fromJson } from "#@typeberry/block-json";
+import { BytesBlob } from "#@typeberry/bytes";
+import { Bootnode } from "#@typeberry/config";
+import { json } from "#@typeberry/json-parser";
+import { isU16 } from "#@typeberry/numbers";
+import { asOpaqueType, WithDebug } from "#@typeberry/utils";
+export function parseBootnode(v) {
+    const [name, ipPort] = v.split("@");
+    // spliting only by last `:` in case of IPv6
+    const ip = ipPort.substring(0, ipPort.lastIndexOf(":"));
+    const port = ipPort.substring(ipPort.lastIndexOf(":") + 1);
+    if (name === "" || ip === "" || port === "") {
+        throw new Error(`Invalid bootnode format, expected: <name>@<ip>:<port>, got: "${v}"`);
+    }
+    const portNumber = Number.parseInt(port, 10);
+    if (!isU16(portNumber)) {
+        throw new Error(`Invalid port number: "${port}"`);
+    }
+    // TODO [ToDr] we should probably validate the name!
+    return new Bootnode(asOpaqueType(name), ip, portNumber);
+}
+/**
+ * Configuration file for any blockchain network built on the JAM protocol
+ *
+ * Provides all the essential information that a new node
+ * needs to join, connect to others, and understand the blockchain's starting point
+ *
+ *  https://github.com/polkadot-fellows/JIPs/blob/90f809b84a9913a821437225f085cf5153870212/JIP-4.md#jip-4-chainspec-file
+ */
+export class JipChainSpec extends WithDebug {
+    /** Optional list of initial contact points for a new node joining the network */
+    bootnodes;
+    /** Human-readable identifier for the network */
+    id;
+    /** Contains the serialized header of the first `block 0` */
+    genesisHeader;
+    /**
+     * Initial state of the blockchain at the moment of its creation
+     *
+     * - `key`: is 31-byte object identifier
+     * - `value`: is the data stored at this location, as BytesBlob of any length.
+     */
+    genesisState;
+    static fromJson = json.object({
+        bootnodes: json.optional(json.array(json.fromString(parseBootnode))),
+        id: "string",
+        genesis_header: fromJson.bytesBlobNoPrefix,
+        genesis_state: json.map(fromJson.bytesNNoPrefix(31), fromJson.bytesBlobNoPrefix),
+    }, (o) => JipChainSpec.create({
+        bootnodes: o.bootnodes,
+        id: o.id,
+        genesisHeader: o.genesis_header,
+        genesisState: o.genesis_state ?? new Map(),
+    }));
+    static create({ bootnodes = [], id = "", genesisHeader = BytesBlob.empty(), genesisState = new Map(), }) {
+        return new JipChainSpec({ bootnodes, id, genesisHeader, genesisState });
+    }
+    constructor(data) {
+        super();
+        this.bootnodes = data.bootnodes;
+        this.id = data.id;
+        this.genesisHeader = data.genesisHeader;
+        this.genesisState = data.genesisState;
+    }
+}

package/packages/jam/config-node/jip-chain-spec.test.d.ts

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

package/packages/jam/config-node/jip-chain-spec.test.d.ts.map

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

package/packages/jam/config-node/jip-chain-spec.test.js

@@ -0,0 +1,109 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { BytesBlob } from "#@typeberry/bytes";
+import { parseFromJson } from "#@typeberry/json-parser";
+import { JipChainSpec } from "./jip-chain-spec.js";
+const JIP_CHAIN_SPEC_TEST = {
+    bootnodes: [
+        "evysk4p563r2kappaebqykryquxw5lfcclvf23dqqhi5n765h4kkb@192.168.50.18:62061",
+        "egy5qba5fyjf7hn7bxeroo7ncqfk5otxvo6or77k23o6pjqnxdoxb@192.168.50.20:63747",
+        "evysk4p563r2kappaebqykryquxw5lfcclvf23dqqhi5n765h4kkb@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:62061",
+        "egy5qba5fyjf7hn7bxeroo7ncqfk5otxvo6or77k23o6pjqnxdoxb@[2001:0db8:85a3:0000:0000:8a2e:0370:7335]:63747",
+    ],
+    id: "testnet",
+    genesis_header: "1ee155ace9c40292074cb6aff8c9ccdd273c81648ff1149ef36bcea6ebb8a3e25bb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aa4aa54d1a89973300d7e2493a1b512fecd848f4e8a63fb3a59d38a6b2c1610d9a2c98544eeb3df",
+    genesis_state: {
+        "01000000000000000000000000000000000000000000000000000000000000": "08b647818aef53ffdf401882ab552f3ea21a57bdfe3fb4554a518a6fea139ca894b0",
+        "09000000000000000000000000000000000000000000000000000000000000": "4aa54d1a89973300d7e2493a1b512fecd848f4e8a63fb3a59d38a6b2c1610d9a2c98",
+        "0f000000000000000000000000000000000000000000000000000000000000": "000000000000000000000000",
+        "0a000000000000000000000000000000000000000000000000000000000000": "0000",
+        "00fe00ff00ff00ffa61a1135d89447673d804e5619daab939cd9c8936d4171": "5000156a616d2d626f6f7473747261702d7365727669636506302e312e32310a",
+    },
+};
+describe("Importing JIP Chain Spec", () => {
+    const ncs = parseFromJson(JIP_CHAIN_SPEC_TEST, JipChainSpec.fromJson);
+    it("should read the net id", () => {
+        assert.deepStrictEqual(ncs.id, "testnet");
+    });
+    it("should read the genesis header", () => {
+        assert.deepStrictEqual(ncs.genesisHeader, BytesBlob.parseBlobNoPrefix("1ee155ace9c40292074cb6aff8c9ccdd273c81648ff1149ef36bcea6ebb8a3e25bb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aa4aa54d1a89973300d7e2493a1b512fecd848f4e8a63fb3a59d38a6b2c1610d9a2c98544eeb3df"));
+    });
+    it("should read bootnodes", () => {
+        assert(ncs.bootnodes !== undefined);
+        for (const bootnode of ncs.bootnodes) {
+            assert(bootnode.id.length > 0);
+            assert(bootnode.ip.length > 0);
+            assert(bootnode.port > 0 && bootnode.port < 65535);
+        }
+    });
+    it("should read genesisState", () => {
+        assert.deepStrictEqual(ncs.genesisState?.size, 5);
+        const value = ncs.genesisState.values().next().value;
+        assert.deepStrictEqual(value, BytesBlob.parseBlobNoPrefix("08b647818aef53ffdf401882ab552f3ea21a57bdfe3fb4554a518a6fea139ca894b0"));
+    });
+    it("should not throw an error when the bootnodes are missing", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            bootnodes: undefined,
+        };
+        assert.doesNotThrow(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+    it("should not throw an error when the bootnodes are empty", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            bootnodes: [],
+        };
+        assert.doesNotThrow(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+});
+describe("Importing JIP Chain Spec: Error Handling", () => {
+    it("should throw an error when the net id is missing", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            id: undefined,
+        };
+        assert.throws(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+    it("should throw an error when the genesis header is missing", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            genesisHeader: undefined,
+        };
+        assert.throws(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+    it("should throw an error when the genesis state is missing", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            genesisState: undefined,
+        };
+        assert.throws(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+    it("should throw an error when bootnode has invalid format (1)", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            bootnodes: ["192.168.50.18:62061"],
+        };
+        assert.throws(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+    it("should throw an error when bootnode has invalid format (2)", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            bootnodes: ["evysk4p563r2kappaebqykryquxw5lfcclvf23dqqhi5n765h4kkb"],
+        };
+        assert.throws(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+    it("should throw an error when bootnode has invalid port (1)", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            bootnodes: ["evysk4p563r2kappaebqykryquxw5lfcclvf23dqqhi5n765h4kkb@192.168.50.18:port"],
+        };
+        assert.throws(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+    it("should throw an error when bootnode has invalid port (2)", () => {
+        const invalidSpec = {
+            ...JIP_CHAIN_SPEC_TEST,
+            bootnodes: ["evysk4p563r2kappaebqykryquxw5lfcclvf23dqqhi5n765h4kkb@192.168.50.18:-62061"],
+        };
+        assert.throws(() => parseFromJson(invalidSpec, JipChainSpec.fromJson));
+    });
+});

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

@@ -0,0 +1,36 @@
+import type { JsonObject } from "#@typeberry/block-json";
+import { PvmBackend } from "#@typeberry/config";
+import { type FromJson } from "#@typeberry/json-parser";
+import { AuthorshipOptions } from "./authorship.js";
+import { JipChainSpec } from "./jip-chain-spec.js";
+/** Development config. Will accept unsealed blocks for now. */
+export declare const DEV_CONFIG = "dev";
+/** Default config file. */
+export declare const DEFAULT_CONFIG = "default";
+export declare const NODE_DEFAULTS: {
+    name: string;
+    config: string[];
+    pvm: PvmBackend;
+};
+/** Chain spec chooser. */
+export declare enum KnownChainSpec {
+    /** Tiny chain spec. */
+    Tiny = "tiny",
+    /** Full chain spec. */
+    Full = "full"
+}
+export declare const knownChainSpecFromJson: FromJson<KnownChainSpec>;
+export declare class NodeConfiguration {
+    readonly $schema: string;
+    readonly version: number;
+    readonly flavor: KnownChainSpec;
+    readonly chainSpec: JipChainSpec;
+    /** If database path is not provided, we load an in-memory db. */
+    readonly databaseBasePath: string | undefined;
+    readonly authorship: AuthorshipOptions;
+    static fromJson: import("@typeberry/json-parser").FromJsonWithParser<unknown, NodeConfiguration>;
+    static new({ $schema, version, flavor, chain_spec, database_base_path, authorship }: JsonObject<NodeConfiguration>): NodeConfiguration;
+    private constructor();
+}
+export declare function loadConfig(config: string[], withRelPath: (p: string) => string): NodeConfiguration;
+//# sourceMappingURL=node-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-config.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/config-node/node-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,EAAE,KAAK,QAAQ,EAAuB,MAAM,wBAAwB,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAInD,+DAA+D;AAC/D,eAAO,MAAM,UAAU,QAAQ,CAAC;AAChC,2BAA2B;AAC3B,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC,eAAO,MAAM,aAAa;;;;CAIzB,CAAC;AAEF,0BAA0B;AAC1B,oBAAY,cAAc;IACxB,uBAAuB;IACvB,IAAI,SAAS;IACb,uBAAuB;IACvB,IAAI,SAAS;CACd;AAED,eAAO,MAAM,sBAAsB,EAS7B,QAAQ,CAAC,cAAc,CAAC,CAAC;AAE/B,qBAAa,iBAAiB;aAqBV,OAAO,EAAE,MAAM;aACf,OAAO,EAAE,MAAM;aACf,MAAM,EAAE,cAAc;aACtB,SAAS,EAAE,YAAY;IACvC,iEAAiE;aACjD,gBAAgB,EAAE,MAAM,GAAG,SAAS;aACpC,UAAU,EAAE,iBAAiB;IA1B/C,MAAM,CAAC,QAAQ,kFAUb;IAEF,MAAM,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,EAAE,UAAU,EAAE,EAAE,UAAU,CAAC,iBAAiB,CAAC;IAOlH,OAAO;CASR;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,iBAAiB,CAkDlG"}

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

@@ -0,0 +1,200 @@
+import fs from "node:fs";
+import os from "node:os";
+import { PvmBackend } from "#@typeberry/config";
+import { configs } from "#@typeberry/configs";
+import { json, parseFromJson } from "#@typeberry/json-parser";
+import { Logger } from "#@typeberry/logger";
+import { isBrowser } from "#@typeberry/utils";
+import { AuthorshipOptions } from "./authorship.js";
+import { JipChainSpec } from "./jip-chain-spec.js";
+const logger = Logger.new(import.meta.filename, "config");
+/** Development config. Will accept unsealed blocks for now. */
+export const DEV_CONFIG = "dev";
+/** Default config file. */
+export const DEFAULT_CONFIG = "default";
+export const NODE_DEFAULTS = {
+    name: isBrowser() ? "browser" : os.hostname(),
+    config: [DEFAULT_CONFIG],
+    pvm: PvmBackend.Ananas,
+};
+/** Chain spec chooser. */
+export var KnownChainSpec;
+(function (KnownChainSpec) {
+    /** Tiny chain spec. */
+    KnownChainSpec["Tiny"] = "tiny";
+    /** Full chain spec. */
+    KnownChainSpec["Full"] = "full";
+})(KnownChainSpec || (KnownChainSpec = {}));
+export const knownChainSpecFromJson = json.fromString((input, ctx) => {
+    switch (input) {
+        case KnownChainSpec.Tiny:
+            return KnownChainSpec.Tiny;
+        case KnownChainSpec.Full:
+            return KnownChainSpec.Full;
+        default:
+            throw Error(`unknown network flavor: ${input} at ${ctx}`);
+    }
+});
+export class NodeConfiguration {
+    $schema;
+    version;
+    flavor;
+    chainSpec;
+    databaseBasePath;
+    authorship;
+    static fromJson = json.object({
+        $schema: "string",
+        version: "number",
+        flavor: knownChainSpecFromJson,
+        chain_spec: JipChainSpec.fromJson,
+        database_base_path: json.optional("string"),
+        authorship: AuthorshipOptions.fromJson,
+    }, NodeConfiguration.new);
+    static new({ $schema, version, flavor, chain_spec, database_base_path, authorship }) {
+        if (version !== 1) {
+            throw new Error("Only version=1 config is supported.");
+        }
+        return new NodeConfiguration($schema, version, flavor, chain_spec, database_base_path ?? undefined, authorship);
+    }
+    constructor($schema, version, flavor, chainSpec, 
+    /** If database path is not provided, we load an in-memory db. */
+    databaseBasePath, authorship) {
+        this.$schema = $schema;
+        this.version = version;
+        this.flavor = flavor;
+        this.chainSpec = chainSpec;
+        this.databaseBasePath = databaseBasePath;
+        this.authorship = authorship;
+    }
+}
+export function loadConfig(config, withRelPath) {
+    logger.log `🔧 Loading config`;
+    let mergedJson = {};
+    for (const entry of config) {
+        logger.log `🔧 Applying '${entry}'`;
+        if (entry === DEV_CONFIG) {
+            mergedJson = structuredClone(configs.dev); // clone to avoid mutating the original config. not doing a merge since dev and default should theoretically replace all properties.
+            continue;
+        }
+        if (entry === DEFAULT_CONFIG) {
+            mergedJson = structuredClone(configs.default);
+            continue;
+        }
+        // try to parse as JSON
+        try {
+            const parsed = JSON.parse(entry);
+            deepMerge(mergedJson, parsed);
+            continue;
+        }
+        catch { }
+        // if not, try to load as file
+        if (entry.indexOf("=") === -1 && entry.endsWith(".json")) {
+            try {
+                const configFile = fs.readFileSync(withRelPath(entry), "utf8");
+                const parsed = JSON.parse(configFile);
+                deepMerge(mergedJson, parsed);
+            }
+            catch (e) {
+                throw new Error(`Unable to load config from ${entry}: ${e}`);
+            }
+        }
+        else {
+            // finally try to process as a pseudo-jq query
+            try {
+                processQuery(mergedJson, entry, withRelPath);
+            }
+            catch (e) {
+                throw new Error(`Error while processing '${entry}': ${e}`);
+            }
+        }
+    }
+    try {
+        const parsed = parseFromJson(mergedJson, NodeConfiguration.fromJson);
+        logger.log `🔧 Config ready`;
+        return parsed;
+    }
+    catch (e) {
+        throw new Error(`Unable to parse config: ${e}`);
+    }
+}
+function deepMerge(target, source) {
+    if (!isJsonObject(source)) {
+        throw new Error(`Expected object, got ${source}`);
+    }
+    for (const key in source) {
+        if (isJsonObject(source[key])) {
+            if (!isJsonObject(target[key])) {
+                target[key] = {};
+            }
+            deepMerge(target[key], source[key]);
+        }
+        else {
+            target[key] = source[key];
+        }
+    }
+}
+/**
+ * Caution: updates input directly.
+ * Processes a pseudo-jq query. Syntax:
+ * .path.to.value = { ... } - updates value with the specified object by replacement
+ * .path.to.value += { ... } - updates value with the specified object by merging
+ * .path.to.value = file.json - updates value with the contents of file.json
+ * .path.to.value += file.json - merges the contents of file.json onto value
+ */
+function processQuery(input, query, withRelPath) {
+    const queryParts = query.split("=");
+    if (queryParts.length === 2) {
+        let [path, value] = queryParts.map((part) => part.trim());
+        let merge = false;
+        // detect += syntax
+        if (path.endsWith("+")) {
+            merge = true;
+            path = path.slice(0, -1);
+        }
+        let parsedValue;
+        if (value.endsWith(".json")) {
+            try {
+                const configFile = fs.readFileSync(withRelPath(value), "utf8");
+                const parsed = JSON.parse(configFile);
+                parsedValue = parsed;
+            }
+            catch (e) {
+                throw new Error(`Unable to load config from ${value}: ${e}`);
+            }
+        }
+        else {
+            try {
+                parsedValue = JSON.parse(value);
+            }
+            catch (e) {
+                throw new Error(`Unrecognized syntax '${value}': ${e}`);
+            }
+        }
+        let pathParts = path.split(".");
+        // allow leading dot in path
+        if (pathParts[0] === "") {
+            pathParts = pathParts.slice(1);
+        }
+        let target = input;
+        for (let i = 0; i < pathParts.length; i++) {
+            const part = pathParts[i];
+            if (!isJsonObject(target[part])) {
+                target[part] = {};
+            }
+            if (i === pathParts.length - 1) {
+                if (merge) {
+                    deepMerge(target[part], parsedValue);
+                }
+                else {
+                    target[part] = parsedValue;
+                }
+                return;
+            }
+            target = target[part];
+        }
+    }
+    throw new Error("Unrecognized syntax.");
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

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

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

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

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

@@ -0,0 +1,177 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import { beforeEach, describe, it, mock } from "node:test";
+import { configs } from "#@typeberry/configs";
+import polkajamConfig from "#@typeberry/configs/typeberry-polkajam-dev.json" with { type: "json" };
+import { parseFromJson } from "#@typeberry/json-parser";
+import { workspacePathFix } from "#@typeberry/utils";
+import { KnownChainSpec, loadConfig, NodeConfiguration } from "./node-config.js";
+const withRelPath = workspacePathFix(`${import.meta.dirname}/../..`);
+const NODE_CONFIG_TEST = {
+    $schema: "https://typeberry.dev/schemas/config-v1.schema.json",
+    version: 1,
+    flavor: "tiny",
+    chain_spec: {
+        bootnodes: [
+            "evysk4p563r2kappaebqykryquxw5lfcclvf23dqqhi5n765h4kkb@192.168.50.18:62061",
+            "egy5qba5fyjf7hn7bxeroo7ncqfk5otxvo6or77k23o6pjqnxdoxb@192.168.50.20:63747",
+        ],
+        id: "testnet",
+        genesis_header: "1ee155ace9c40292074cb6aff8c9ccdd273c81648ff1149ef36bcea6ebb8a3e25bb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aa4aa54d1a89973300d7e2493a1b512fecd848f4e8a63fb3a59d38a6b2c1610d9a2c98544eeb3df",
+        genesis_state: {
+            "01000000000000000000000000000000000000000000000000000000000000": "08b647818aef53ffdf401882ab552f3ea21a57bdfe3fb4554a518a6fea139ca894b0",
+            "09000000000000000000000000000000000000000000000000000000000000": "4aa54d1a89973300d7e2493a1b512fecd848f4e8a63fb3a59d38a6b2c1610d9a2c98",
+        },
+    },
+    database_base_path: "/tmp/jam-node-db",
+    authorship: {},
+};
+describe("Importing Node Configuration", () => {
+    const config = parseFromJson(NODE_CONFIG_TEST, NodeConfiguration.fromJson);
+    it("should read the schema", () => {
+        assert.deepStrictEqual(config.$schema, "https://typeberry.dev/schemas/config-v1.schema.json");
+    });
+    it("should read the version", () => {
+        assert.deepStrictEqual(config.version, 1);
+    });
+    it("should read the flavor", () => {
+        assert.deepStrictEqual(config.flavor, KnownChainSpec.Tiny);
+    });
+    it("should read the database base path", () => {
+        assert.deepStrictEqual(config.databaseBasePath, "/tmp/jam-node-db");
+    });
+    it("should read the chain spec", () => {
+        assert.deepStrictEqual(config.chainSpec.id, "testnet");
+        assert(config.chainSpec.bootnodes !== undefined);
+        assert.deepStrictEqual(config.chainSpec.bootnodes.length, 2);
+    });
+});
+describe("Importing Node Configuration: Error Handling", () => {
+    it("should throw an error when version is not 1", () => {
+        const invalidConfig = {
+            ...NODE_CONFIG_TEST,
+            version: 2,
+        };
+        assert.throws(() => parseFromJson(invalidConfig, NodeConfiguration.fromJson));
+    });
+});
+describe("Load dev config", () => {
+    it("should load dev config without crashing", () => {
+        loadConfig(["dev"], withRelPath);
+    });
+});
+describe("loadConfig", () => {
+    beforeEach(() => {
+        mock.restoreAll();
+    });
+    it("should load default config", () => {
+        const config = loadConfig(["default"], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson(configs.default, NodeConfiguration.fromJson));
+    });
+    it("should load dev config", () => {
+        const config = loadConfig(["dev"], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson(configs.dev, NodeConfiguration.fromJson));
+    });
+    it("should parse inline json config and deep merge onto previous entries", () => {
+        const config = loadConfig(["default", JSON.stringify({ database_base_path: "/test/path", chain_spec: { bootnodes: [] } })], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson({
+            ...configs.default,
+            database_base_path: "/test/path",
+            chain_spec: { ...configs.default.chain_spec, bootnodes: [] },
+        }, NodeConfiguration.fromJson));
+    });
+    it("should load config from file if a valid file path is specified", () => {
+        mock.method(fs, "readFileSync", (src) => {
+            if (src === withRelPath("file.json")) {
+                return JSON.stringify(polkajamConfig);
+            }
+            throw new Error(`File ${src} not found`);
+        });
+        const config = loadConfig(["file.json"], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson(polkajamConfig, NodeConfiguration.fromJson));
+    });
+    it("should load config from file and deep merge onto previous entries", () => {
+        mock.method(fs, "readFileSync", (src) => {
+            if (src === withRelPath("file.json")) {
+                return JSON.stringify({ chain_spec: { bootnodes: [] } });
+            }
+            throw new Error(`File ${src} not found`);
+        });
+        const config = loadConfig(["default", "file.json"], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson({
+            ...configs.default,
+            chain_spec: { ...configs.default.chain_spec, bootnodes: [] },
+        }, NodeConfiguration.fromJson));
+    });
+    it("should apply pseudo-jq queries by replacement", () => {
+        const config = loadConfig(["default", ".chain_spec.bootnodes=[]"], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson({
+            ...configs.default,
+            chain_spec: { ...configs.default.chain_spec, bootnodes: [] },
+        }, NodeConfiguration.fromJson));
+    });
+    it("should apply pseudo-jq queries by merging", () => {
+        const config = loadConfig(["default", `.chain_spec+={"bootnodes": []}`], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson({
+            ...configs.default,
+            chain_spec: { ...configs.default.chain_spec, bootnodes: [] },
+        }, NodeConfiguration.fromJson));
+    });
+    it("should load config from files specified in a pseudo-jq query", () => {
+        mock.method(fs, "readFileSync", (src) => {
+            if (src === withRelPath("file.json")) {
+                return JSON.stringify({ bootnodes: [] });
+            }
+            throw new Error(`File ${src} not found`);
+        });
+        const config = loadConfig(["default", ".chain_spec+=file.json"], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson({
+            ...configs.default,
+            chain_spec: { ...configs.default.chain_spec, bootnodes: [] },
+        }, NodeConfiguration.fromJson));
+    });
+    it("should stack several config entries in order from left to right", () => {
+        const config = loadConfig([
+            "dev",
+            `.chain_spec+={"bootnodes": []}`,
+            `.database_base_path="/test/path"`,
+            `.database_base_path="/test/path-1"`,
+        ], withRelPath);
+        assert.deepStrictEqual(config, parseFromJson({
+            ...configs.dev,
+            database_base_path: "/test/path-1",
+            chain_spec: { ...configs.dev.chain_spec, bootnodes: [] },
+        }, NodeConfiguration.fromJson));
+    });
+    it("should throw an error if an invalid json file is provided", () => {
+        mock.method(fs, "readFileSync", () => "invalid json");
+        assert.throws(() => loadConfig(["file.json"], withRelPath), new Error(`Unable to load config from file.json: SyntaxError: Unexpected token 'i', "invalid json" is not valid JSON`));
+    });
+    it("should throw an error if non-existing json file path is provided", () => {
+        mock.method(fs, "readFileSync", () => {
+            throw new Error("File not found");
+        });
+        assert.throws(() => loadConfig(["file.json"], withRelPath), new Error("Unable to load config from file.json: Error: File not found"));
+    });
+    it("should throw an error if an invalid json file is provided using a pseudo-jq query", () => {
+        mock.method(fs, "readFileSync", () => "invalid json");
+        assert.throws(() => loadConfig(["default", ".chain_spec+=file.json"], withRelPath), new Error(`Error while processing '.chain_spec+=file.json': Error: Unable to load config from file.json: SyntaxError: Unexpected token 'i', "invalid json" is not valid JSON`));
+    });
+    it("should throw an error if non-existing json file path is provided using a pseudo-jq query", () => {
+        mock.method(fs, "readFileSync", () => {
+            throw new Error("File not found");
+        });
+        assert.throws(() => loadConfig(["default", ".chain_spec+=file.json"], withRelPath), new Error("Error while processing '.chain_spec+=file.json': Error: Unable to load config from file.json: Error: File not found"));
+    });
+    it("should throw an error if the right side of a pseudo-jq query is not a valid json", () => {
+        mock.method(fs, "existsSync", () => false);
+        assert.throws(() => loadConfig(["default", ".chain_spec+=invalid json"], withRelPath), new Error(`Error while processing '.chain_spec+=invalid json': Error: Unrecognized syntax 'invalid json': SyntaxError: Unexpected token 'i', "invalid json" is not valid JSON`));
+    });
+    it("should throw an error if the provided config is neither of the valid options (inline json, file path, pseudo-jq query)", () => {
+        mock.method(fs, "existsSync", () => false);
+        assert.throws(() => loadConfig(["invalid config"], withRelPath), new Error("Error while processing 'invalid config': Error: Unrecognized syntax."));
+    });
+    it("should throw an error if the provided config has valid syntax but the resulting data is not a valid node config", () => {
+        assert.throws(() => loadConfig(["default", ".chain_spec=1"], withRelPath), new Error("Unable to parse config: Error: [<root>] Error while parsing the value: Error: [<root>.chain_spec] Error while parsing the value: Error: [<root>.chain_spec] Expected complex type but got number"));
+    });
+});

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

@@ -0,0 +1,48 @@
+import type { BlockView, ExtrinsicView, HeaderHash, HeaderView, StateRootHash } from "#@typeberry/block";
+import { type WithHash } from "#@typeberry/hash";
+/**
+ * Blockchain database interface.
+ */
+export interface BlocksDb {
+    /** Mark given header hash as the best block. */
+    setBestHeaderHash(hash: HeaderHash): Promise<void>;
+    /** Retrieve current best header hash. */
+    getBestHeaderHash(): HeaderHash;
+    /** Set the posterior state root hash of given block. */
+    setPostStateRoot(hash: HeaderHash, postStateRoot: StateRootHash): Promise<void>;
+    /** Get posterior state root of given block hash. */
+    getPostStateRoot(hash: HeaderHash): StateRootHash | null;
+    /** Insert and flush a new block into the database. */
+    insertBlock(block: WithHash<HeaderHash, BlockView>): Promise<void>;
+    /** Retrieve header by hash. */
+    getHeader(hash: HeaderHash): HeaderView | null;
+    /**
+     * Retrieve extrinsic data by hash of the header they are part of.
+     *
+     * NOTE: this is not extrinsic hash!
+     */
+    getExtrinsic(hash: HeaderHash): ExtrinsicView | null;
+    /** Close the database and free resources. */
+    close(): Promise<void>;
+}
+/** In-memory (non-persistent) blocks database. */
+export declare class InMemoryBlocks implements BlocksDb {
+    private readonly headersByHash;
+    private readonly extrinsicsByHeaderHash;
+    private readonly postStateRootByHeaderHash;
+    private bestHeaderHash;
+    /** Create empty blocks db. */
+    static new(): InMemoryBlocks;
+    /** Create new `InMemoryBlocks` and insert all given blocks. */
+    static fromBlocks(previousBlocks: WithHash<HeaderHash, BlockView>[]): InMemoryBlocks;
+    private constructor();
+    setBestHeaderHash(hash: HeaderHash): Promise<void>;
+    getBestHeaderHash(): HeaderHash;
+    setPostStateRoot(hash: HeaderHash, postStateRoot: StateRootHash): Promise<void>;
+    getPostStateRoot(hash: HeaderHash): StateRootHash | null;
+    insertBlock(block: WithHash<HeaderHash, BlockView>): Promise<void>;
+    getHeader(hash: HeaderHash): HeaderView | null;
+    getExtrinsic(hash: HeaderHash): ExtrinsicView | null;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=blocks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/database/blocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGxG,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,gDAAgD;IAChD,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,yCAAyC;IACzC,iBAAiB,IAAI,UAAU,CAAC;IAChC,wDAAwD;IACxD,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,oDAAoD;IACpD,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI,CAAC;IACzD,sDAAsD;IACtD,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,+BAA+B;IAC/B,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;IAC/C;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI,CAAC;IACrD,6CAA6C;IAC7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,kDAAkD;AAClD,qBAAa,cAAe,YAAW,QAAQ;IAC7C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgE;IAC9F,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAmE;IAC1G,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAmE;IAC7G,OAAO,CAAC,cAAc,CAAgD;IAEtE,8BAA8B;IAC9B,MAAM,CAAC,GAAG;IAIV,+DAA+D;IAC/D,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC,EAAE;IAQnE,OAAO;IAEP,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlD,iBAAiB,IAAI,UAAU;IAI/B,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAK/E,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI;IAIxD,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAOlE,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI;IAI9C,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI;IAI9C,KAAK;CACZ"}