@typeberry/lib 0.6.2-9d23bc2 → 0.7.0-4f16a18

package/bin/lib/scripts/build-lib.js

@@ -60,7 +60,6 @@
  *     └── workers/
  * ```
  */
-import { execSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -71,26 +70,26 @@ const DIST_DIR = path.resolve(ROOT_DIR, "dist/lib");
 /**
  * Get the version string for the package
  *
- * If IS_RELEASE environment variable is set, uses the version from package.json as-is.
- * Otherwise, appends the current git commit hash to create unique versions for each build.
+ * If the VERSION_SHA environment variable is set (e.g. CI builds), appends it to
+ * the base version to create a unique, non-release version. Otherwise (release
+ * behavior) the base version from package.json is used as-is.
  *
  * @param baseVersion - The base version from package.json
  * @returns The version string to use for publishing
  *
  * @example
- * // When IS_RELEASE is not set and commit is abc1234
+ * // When VERSION_SHA=abc1234
  * getVersion("0.5.1") // Returns "0.5.1-abc1234"
  *
- * // When IS_RELEASE is set
+ * // When VERSION_SHA is not set
  * getVersion("0.5.1") // Returns "0.5.1"
  */
 function getVersion(baseVersion) {
-    const isRelease = Boolean(process.env.IS_RELEASE);
-    if (isRelease) {
+    const versionSha = process.env.VERSION_SHA;
+    if (versionSha === undefined || versionSha === "") {
         return baseVersion;
     }
-    const commitHash = execSync("git rev-parse --short HEAD").toString("utf8").trim();
-    return `${baseVersion}-${commitHash}`;
+    return `${baseVersion}-${versionSha}`;
 }
 /**
  * Build a map of package names to their workspace paths

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typeberry/lib",
-  "version": "0.6.2-9d23bc2",
+  "version": "0.7.0-4f16a18",
   "description": "Typeberry Library",
   "main": "./bin/lib/index.js",
   "types": "./bin/lib/index.d.ts",

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

@@ -7,6 +7,18 @@ export type FuzzConfig = {
     socket: string | null;
     initGenesisFromAncestry: boolean;
 };
+/**
+ * Resolve the directory the fuzzer should use for its on-disk database, or
+ * `undefined` for an in-memory database. The dedicated `FUZZ_DB_SUBDIR` is
+ * appended so we only ever wipe a directory the fuzzer owns, never the base
+ * path the harness handed us.
+ *
+ * The empty / "undefined" guards are defensive: the env flow already normalizes via fuzzDatabaseBasePath,
+ * but the CLI fuzz-target path can set databaseBasePath directly without going through fuzz-env's normalization.
+ */
+export declare function resolveFuzzDbBase(configured: string | undefined): string | undefined;
+/** Recursively remove the fuzzer's database directory. No-op if it is absent. */
+export declare function wipeFuzzDb(base: string): Promise<void>;
 export declare function getFuzzDetails(): {
     nodeName: string;
     nodeVersion: fuzzV1.Version;

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

@@ -1 +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;AAIjD,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,uBAwExF"}
+{"version":3,"file":"main-fuzz.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main-fuzz.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,EAAE,IAAI,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAOrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD,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;AAOF;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CASpF;AAED,iFAAiF;AACjF,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5D;AAED,wBAAgB,cAAc;;;;EAM7B;AAED,wBAAsB,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,uBAiGxF"}

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

@@ -1,3 +1,4 @@
+import { rm } from "node:fs/promises";
 import { Header } from "#@typeberry/block";
 import { Bytes } from "#@typeberry/bytes";
 import { Encoder } from "#@typeberry/codec";
@@ -7,9 +8,35 @@ import { v1 as fuzzV1 } from "#@typeberry/fuzz-proto";
 import { HASH_SIZE } from "#@typeberry/hash";
 import { Logger } from "#@typeberry/logger";
 import { CURRENT_VERSION, Result, version } from "#@typeberry/utils";
+import { logHostEnvironment } from "#@typeberry/workers-api-node";
 import { getChainSpec } from "./common.js";
 import { mainImporter } from "./main-importer.js";
 const logger = Logger.new(import.meta.filename, "fuzztarget");
+/** Dedicated subdirectory under the configured base path that the fuzzer owns and wipes. */
+const FUZZ_DB_SUBDIR = "typeberry-fuzz-db";
+/**
+ * Resolve the directory the fuzzer should use for its on-disk database, or
+ * `undefined` for an in-memory database. The dedicated `FUZZ_DB_SUBDIR` is
+ * appended so we only ever wipe a directory the fuzzer owns, never the base
+ * path the harness handed us.
+ *
+ * The empty / "undefined" guards are defensive: the env flow already normalizes via fuzzDatabaseBasePath,
+ * but the CLI fuzz-target path can set databaseBasePath directly without going through fuzz-env's normalization.
+ */
+export function resolveFuzzDbBase(configured) {
+    if (configured === undefined) {
+        return undefined;
+    }
+    const trimmed = configured.trim();
+    if (trimmed === "" || trimmed.toLowerCase() === "undefined") {
+        return undefined;
+    }
+    return `${trimmed}/${FUZZ_DB_SUBDIR}`;
+}
+/** Recursively remove the fuzzer's database directory. No-op if it is absent. */
+export async function wipeFuzzDb(base) {
+    await rm(base, { recursive: true, force: true });
+}
 export function getFuzzDetails() {
     return {
         nodeName: "@typeberry/jam",
@@ -20,7 +47,9 @@ export function getFuzzDetails() {
 export async function mainFuzz(fuzzConfig, withRelPath) {
     logger.info `💨 Fuzzer V${fuzzConfig.version} starting up.`;
     logger.info `🖥️ PVM Backend: ${PvmBackend[fuzzConfig.jamNodeConfig.pvmBackend]}.`;
+    logHostEnvironment(logger);
     const { jamNodeConfig: config } = fuzzConfig;
+    const fuzzDbBase = resolveFuzzDbBase(config.node.databaseBasePath);
     let runningNode = null;
     const chainSpec = getChainSpec(config.node.flavor);
     const closeFuzzTarget = startFuzzTarget(fuzzConfig.version, fuzzConfig.socket, {
@@ -51,13 +80,11 @@ export async function mainFuzz(fuzzConfig, withRelPath) {
                 runningNode = null;
                 await finish;
             }
-            // update the chainspec
-            const newNode = await mainImporter({
+            const buildNode = (databaseBasePath) => mainImporter({
                 ...config,
                 node: {
                     ...config.node,
-                    // use in-memory db
-                    databaseBasePath: undefined,
+                    databaseBasePath,
                     chainSpec: {
                         ...config.node.chainSpec,
                         genesisHeader: Encoder.encodeObject(Header.Codec, header, chainSpec),
@@ -71,9 +98,30 @@ export async function mainFuzz(fuzzConfig, withRelPath) {
                 dummyFinalityDepth: 10_000,
                 pruneBlocks: true,
             });
-            runningNode = newNode;
-            return await newNode.getBestStateRootHash();
+            if (fuzzDbBase !== undefined) {
+                // Each reset starts a fresh session from the genesis the fuzzer just sent,
+                // so the on-disk db must be empty: otherwise initializeDatabase sees an
+                // already-initialized db and silently resumes the previous run's state.
+                await wipeFuzzDb(fuzzDbBase);
+                try {
+                    runningNode = await buildNode(fuzzDbBase);
+                    return await runningNode.getBestStateRootHash();
+                }
+                catch (e) {
+                    // A partially-opened db may leak on failure; acceptable for this degraded fallback (proper cleanup belongs in mainImporter).
+                    logger.warn `Failed to open persistent fuzz db at ${fuzzDbBase}, falling back to in-memory: ${e}`;
+                    runningNode = null;
+                }
+            }
+            runningNode = await buildNode(undefined);
+            return await runningNode.getBestStateRootHash();
         },
     });
-    return closeFuzzTarget;
+    return () => {
+        closeFuzzTarget();
+        if (fuzzDbBase !== undefined) {
+            // best-effort cleanup on shutdown; ignore failures (dir may already be gone).
+            wipeFuzzDb(fuzzDbBase).catch(() => { });
+        }
+    };
 }

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

@@ -1,7 +1,9 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
 import { describe, it } from "node:test";
 import { tryAsU8 } from "#@typeberry/numbers";
 import { CURRENT_VERSION, deepEqual, version } from "#@typeberry/utils";
-import { getFuzzDetails } from "./main-fuzz.js";
+import { getFuzzDetails, resolveFuzzDbBase, wipeFuzzDb } from "./main-fuzz.js";
 describe("fuzzing config", () => {
     it("should create config from current version", () => {
         const [m, i, p] = version.split(".").map((x) => Number.parseInt(x, 10));
@@ -22,3 +24,30 @@ describe("fuzzing config", () => {
         }, { ignore: ["nodeVersion.patch"] });
     });
 });
+describe("resolveFuzzDbBase", () => {
+    it("returns undefined when no base path is configured", () => {
+        assert.strictEqual(resolveFuzzDbBase(undefined), undefined);
+    });
+    it("returns undefined for empty and the 'undefined' sentinel", () => {
+        assert.strictEqual(resolveFuzzDbBase(""), undefined);
+        assert.strictEqual(resolveFuzzDbBase("  undefined  "), undefined);
+    });
+    it("appends the dedicated fuzz subdir for a real path", () => {
+        assert.strictEqual(resolveFuzzDbBase("/tmp/jam-data"), "/tmp/jam-data/typeberry-fuzz-db");
+    });
+});
+describe("wipeFuzzDb", () => {
+    it("removes an existing directory and its contents", async () => {
+        const dir = fs.mkdtempSync("typeberry-fuzz-wipe-");
+        fs.writeFileSync(`${dir}/marker`, "x");
+        await wipeFuzzDb(dir);
+        assert.strictEqual(fs.existsSync(dir), false);
+    });
+    it("is a no-op when the directory does not exist", async () => {
+        const dir = fs.mkdtempSync("typeberry-fuzz-wipe-");
+        fs.rmSync(dir, { recursive: true, force: true });
+        // must not throw
+        await wipeFuzzDb(dir);
+        assert.strictEqual(fs.existsSync(dir), false);
+    });
+});