nano-pow 3.2.1 → 4.0.0

package/dist/bin/cli.js

@@ -4,6 +4,7 @@
 import * as fs from "node:fs/promises";
 import * as readline from "node:readline/promises";
 import * as puppeteer from "puppeteer";
+import { cliHelp } from "../../docs/index.js";
 const hashes = [];
 const stdinErrors = [];
 if (!process.stdin.isTTY) {
@@ -20,25 +21,7 @@ if (!process.stdin.isTTY) {
 }
 const args = process.argv.slice(2);
 if (hashes.length === 0 && args.length === 0 || args.some((v) => v === "--help" || v === "-h")) {
-  console.log(`Usage: nano-pow [OPTION]... BLOCKHASH...
-Generate work for BLOCKHASH, or multiple work values for BLOCKHASH(es)
-BLOCKHASH is a 64-character hexadecimal string. Multiple blockhashes must be separated by whitespace or line breaks.
-Prints a 16-character hexadecimal work value to standard output. If using --validate, prints 'true' or 'false' to standard output instead.
-
-  -h, --help                  show this dialog
-  -d, --debug                 enable additional logging output
-	-j, --json                  format output as JSON
-  -e, --effort=<value>        increase demand on GPU processing
-  -t, --threshold=<value>     override the minimum threshold value
-  -v, --validate=<value>      check an existing work value instead of searching for one
-
-If validating a nonce, it must be a 16-character hexadecimal value.
-Effort must be a decimal number between 1-32.
-Threshold must be a hexadecimal string between 0-FFFFFFFF.
-
-Report bugs: <bug-nano-pow@zoso.dev>
-Full documentation: <https://www.npmjs.com/package/nano-pow>
-`);
+  console.log(cliHelp);
   process.exit();
 }
 const inArgs = [];

package/dist/bin/server.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+//! SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
+//! SPDX-License-Identifier: GPL-3.0-or-later
+import * as http from "node:http";
+import * as fs from "node:fs/promises";
+import * as puppeteer from "puppeteer";
+import { serverHelp } from "../../docs/index.js";
+const PORT = process.env.PORT || 3e3;
+function log(...args) {
+  console.log(new Date(Date.now()).toLocaleString(), "NanoPow", args);
+}
+log("Starting server");
+const NanoPow = await fs.readFile(new URL("../main.min.js", import.meta.url), "utf-8");
+let browser;
+let page;
+async function work_generate(res, json) {
+  if (!/^[0-9A-Fa-f]{64}$/.test(json.hash ?? "")) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Invalid hash. Must be a 64-character hex string." }));
+    return;
+  }
+  if (json.difficulty && !/^[1-9A-Fa-f][0-9A-Fa-f]{0,15}$/.test(json.difficulty)) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Invalid difficulty. Must be a hexadecimal string between 1-FFFFFFFFFFFFFFFF." }));
+    return;
+  }
+  try {
+    const result = await page.evaluate(async (args) => {
+      const options = {
+        debug: true
+      };
+      if (args.difficulty) options.threshold = BigInt(`0x${args.difficulty}`);
+      return await window.NanoPow.work_generate(args.hash, options);
+    }, json);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(result));
+  } catch (err) {
+    log("work_generate error:", err);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "work_generate failed" }));
+  }
+}
+async function work_validate(res, json) {
+  if (!/^[0-9A-Fa-f]{64}$/.test(json.hash ?? "")) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Invalid hash. Must be a 64-character hex string." }));
+    return;
+  }
+  if (json.difficulty && !/^[1-9A-Fa-f][0-9A-Fa-f]{0,15}$/.test(json.difficulty)) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Invalid difficulty. Must be a hexadecimal string between 1-FFFFFFFFFFFFFFFF." }));
+    return;
+  }
+  if (!/^[0-9A-Fa-f]{16}$/.test(json.work ?? "")) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Invalid work. Must be a 16-character hex string." }));
+    return;
+  }
+  try {
+    const result = await page.evaluate(async (args) => {
+      const options = {
+        debug: true
+      };
+      if (args.difficulty) options.threshold = BigInt(`0x${args.difficulty}`);
+      return await window.NanoPow.work_validate(args.work, args.hash, options);
+    }, json);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(result));
+  } catch (err) {
+    log("work_validate error:", err);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "work_validate failed" }));
+  }
+}
+(async () => {
+  browser = await puppeteer.launch({
+    headless: true,
+    args: [
+      "--headless=new",
+      "--use-angle=vulkan",
+      "--enable-features=Vulkan",
+      "--disable-vulkan-surface",
+      "--enable-unsafe-webgpu"
+    ]
+  });
+  page = await browser.newPage();
+  page.on("console", (msg) => {
+    log(msg.text());
+  });
+  await fs.writeFile(`${import.meta.dirname}/server.html`, "");
+  await page.goto(import.meta.resolve("./server.html"));
+  await page.waitForFunction(async () => {
+    return await navigator.gpu.requestAdapter();
+  });
+  const inject = `${NanoPow};window.NanoPow=NanoPow;`;
+  const hash = await crypto.subtle.digest("SHA-256", Buffer.from(inject, "utf-8"));
+  const src = `sha256-${Buffer.from(hash).toString("base64")}`;
+  await page.setContent(`
+		<!DOCTYPE html>
+			<head>
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none'; base-uri 'none'; form-action 'none'; script-src '${src}';">
+				<script type="module">${inject}</script>
+			</head>
+		</html>
+	`);
+  await fs.unlink(`${import.meta.dirname}/server.html`);
+  log("Puppeteer initialized");
+  const server = http.createServer(async (req, res) => {
+    let data = [];
+    if (req.method === "POST") {
+      req.on("data", (chunk) => {
+        data.push(chunk);
+      });
+      req.on("end", async () => {
+        let json;
+        try {
+          json = JSON.parse(Buffer.concat(data).toString());
+        } catch (err) {
+          log("JSON.parse error:", err);
+          log("Failed JSON:", json);
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid data." }));
+          return;
+        }
+        switch (json.action) {
+          case "work_generate": {
+            await work_generate(res, json);
+            break;
+          }
+          case "work_validate": {
+            await work_validate(res, json);
+            break;
+          }
+          default: {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `Invalid data.` }));
+            return;
+          }
+        }
+      });
+    } else {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end(serverHelp);
+    }
+  });
+  server.on("error", (e) => {
+    log("Server error", e);
+    try {
+      shutdown();
+    } catch (err) {
+      log("Failed to shut down", err);
+      process.exit(1);
+    }
+  });
+  server.listen(PORT, () => {
+    process.title = "NanoPow Server";
+    log(`Server process ${process.pid} running at http://localhost:${PORT}/`);
+  });
+  function shutdown() {
+    log("Shutdown signal received");
+    const kill = setTimeout(() => {
+      log("Server unresponsive, forcefully stopped");
+      process.exit(1);
+    }, 1e4);
+    server.close(async () => {
+      await page?.close();
+      await browser?.close();
+      clearTimeout(kill);
+      log("Server stopped");
+      process.exit(0);
+    });
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+})();

package/dist/main.min.js

@@ -345,22 +345,10 @@ var NanoPowGl = class _NanoPowGl {
   * Finds a nonce that satisfies the Nano proof-of-work requirements.
   *
   * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-  * @param {NanoPowOptions} options - Used to configure search execution
-  */
-  static async search(hash, options) {
-    if (options?.threshold != null) {
-      options.threshold = BigInt(`0x${options.threshold.toString(16) ?? "0"}00000000`);
-    }
-    const result = await this.work_generate(hash, options);
-    return result.work;
-  }
-  /**
-  * Finds a nonce that satisfies the Nano proof-of-work requirements.
-  *
-  * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
   * @param {NanoPowOptions} options - Options used to configure search execution
   */
   static async work_generate(hash, options) {
+    if (!/^[A-Fa-f0-9]{64}$/.test(hash)) throw new Error(`Invalid hash ${hash}`);
     if (this.#busy) {
       console.log("NanoPowGl is busy. Retrying search...");
       return new Promise((resolve) => {
@@ -371,11 +359,17 @@ var NanoPowGl = class _NanoPowGl {
       });
     }
     this.#busy = true;
-    if (!/^[A-Fa-f0-9]{64}$/.test(hash)) throw new Error(`Invalid hash ${hash}`);
+    if (typeof options?.threshold === "string") {
+      try {
+        options.threshold = BigInt(`0x${options.threshold}`);
+      } catch (err) {
+        throw new TypeError(`Invalid threshold ${options.threshold}`);
+      }
+    }
     const threshold = typeof options?.threshold !== "bigint" || options.threshold < 1n || options.threshold > 0xffffffffffffffffn ? 0xfffffff800000000n : options.threshold;
     const effort = typeof options?.effort !== "number" || options.effort < 1 || options.effort > 32 ? this.#cores : options.effort;
     this.#debug = !!options?.debug;
-    if (this.#debug) console.log("NanoPowGl.search()");
+    if (this.#debug) console.log("NanoPowGl.work_generate()");
     if (this.#debug) console.log("blockhash", hash);
     if (this.#debug) console.log("search options", JSON.stringify(options, (k, v) => typeof v === "bigint" ? v.toString(16) : v));
     if (this.#WORKLOAD !== 256 * effort) {
@@ -436,21 +430,9 @@ var NanoPowGl = class _NanoPowGl {
   * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
   * @param {NanoPowOptions} options - Options used to configure search execution
   */
-  static async validate(work, hash, options) {
-    if (options?.threshold != null) {
-      options.threshold = BigInt(`0x${options.threshold.toString(16) ?? "0"}00000000`);
-    }
-    const result = await this.work_validate(work, hash, options);
-    return options?.threshold != null ? result.valid === "1" : result.valid_all === "1";
-  }
-  /**
-  * Validates that a nonce satisfies Nano proof-of-work requirements.
-  *
-  * @param {string} work - Hexadecimal proof-of-work value to validate
-  * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-  * @param {NanoPowOptions} options - Options used to configure search execution
-  */
   static async work_validate(work, hash, options) {
+    if (!/^[A-Fa-f0-9]{16}$/.test(work)) throw new Error(`Invalid work ${work}`);
+    if (!/^[A-Fa-f0-9]{64}$/.test(hash)) throw new Error(`Invalid hash ${hash}`);
     if (this.#busy) {
       console.log("NanoPowGl is busy. Retrying validate...");
       return new Promise((resolve) => {
@@ -461,11 +443,16 @@ var NanoPowGl = class _NanoPowGl {
       });
     }
     this.#busy = true;
-    if (!/^[A-Fa-f0-9]{16}$/.test(work)) throw new Error(`Invalid work ${work}`);
-    if (!/^[A-Fa-f0-9]{64}$/.test(hash)) throw new Error(`Invalid hash ${hash}`);
+    if (typeof options?.threshold === "string") {
+      try {
+        options.threshold = BigInt(`0x${options.threshold}`);
+      } catch (err) {
+        throw new TypeError(`Invalid threshold ${options.threshold}`);
+      }
+    }
     const threshold = typeof options?.threshold !== "bigint" || options.threshold < 1n || options.threshold > 0xffffffffffffffffn ? 0xfffffff800000000n : options.threshold;
     this.#debug = !!options?.debug;
-    if (this.#debug) console.log("NanoPowGl.validate()");
+    if (this.#debug) console.log("NanoPowGl.work_validate()");
     if (this.#debug) console.log("blockhash", hash);
     if (this.#debug) console.log("validate options", JSON.stringify(options, (k, v) => typeof v === "bigint" ? v.toString(16) : v));
     if (_NanoPowGl.#gl == null) throw new Error("WebGL 2 is required");
@@ -706,19 +693,6 @@ var NanoPowGpu = class _NanoPowGpu {
   * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
   * @param {NanoPowOptions} options - Used to configure search execution
   */
-  static async search(hash, options) {
-    if (options?.threshold != null) {
-      options.threshold = BigInt(`0x${options.threshold.toString(16) ?? "0"}00000000`);
-    }
-    const result = await this.work_generate(hash, options);
-    return result.work;
-  }
-  /**
-  * Finds a nonce that satisfies the Nano proof-of-work requirements.
-  *
-  * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-  * @param {NanoPowOptions} options - Used to configure search execution
-  */
   static async work_generate(hash, options) {
     if (!/^[A-Fa-f0-9]{64}$/.test(hash)) throw new TypeError(`Invalid hash ${hash}`);
     if (this.#busy) {
@@ -731,10 +705,17 @@ var NanoPowGpu = class _NanoPowGpu {
       });
     }
     this.#busy = true;
+    if (typeof options?.threshold === "string") {
+      try {
+        options.threshold = BigInt(`0x${options.threshold}`);
+      } catch (err) {
+        throw new TypeError(`Invalid threshold ${options.threshold}`);
+      }
+    }
     const threshold = typeof options?.threshold !== "bigint" || options.threshold < 1n || options.threshold > 0xffffffffffffffffn ? 0xfffffff800000000n : options.threshold;
     const effort = typeof options?.effort !== "number" || options.effort < 1 || options.effort > 32 ? 2048 : options.effort * 256;
     this.#debug = !!options?.debug;
-    if (this.#debug) console.log("NanoPowGpu.search()");
+    if (this.#debug) console.log("NanoPowGpu.work_generate()");
     if (this.#debug) console.log("blockhash", hash);
     if (this.#debug) console.log("search options", JSON.stringify(options, (k, v) => typeof v === "bigint" ? v.toString(16) : v));
     let loads = 0;
@@ -780,20 +761,6 @@ var NanoPowGpu = class _NanoPowGpu {
   * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
   * @param {NanoPowOptions} options - Options used to configure search execution
   */
-  static async validate(work, hash, options) {
-    if (options?.threshold != null) {
-      options.threshold = BigInt(`0x${options.threshold.toString(16) ?? "0"}00000000`);
-    }
-    const result = await this.work_validate(work, hash, options);
-    return options?.threshold != null ? result.valid === "1" : result.valid_all === "1";
-  }
-  /**
-  * Validates that a nonce satisfies Nano proof-of-work requirements.
-  *
-  * @param {string} work - Hexadecimal proof-of-work value to validate
-  * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-  * @param {NanoPowOptions} options - Options used to configure search execution
-  */
   static async work_validate(work, hash, options) {
     if (!/^[A-Fa-f0-9]{16}$/.test(work)) throw new TypeError(`Invalid work ${work}`);
     if (!/^[A-Fa-f0-9]{64}$/.test(hash)) throw new TypeError(`Invalid hash ${hash}`);
@@ -807,9 +774,16 @@ var NanoPowGpu = class _NanoPowGpu {
       });
     }
     this.#busy = true;
+    if (typeof options?.threshold === "string") {
+      try {
+        options.threshold = BigInt(`0x${options.threshold}`);
+      } catch (err) {
+        throw new TypeError(`Invalid threshold ${options.threshold}`);
+      }
+    }
     const threshold = typeof options?.threshold !== "bigint" || options.threshold < 1n || options.threshold > 0xffffffffffffffffn ? 0xfffffff800000000n : options.threshold;
     this.#debug = !!options?.debug;
-    if (this.#debug) console.log("NanoPowGpu.validate()");
+    if (this.#debug) console.log("NanoPowGpu.work_validate()");
     if (this.#debug) console.log("blockhash", hash);
     if (this.#debug) console.log("validate options", JSON.stringify(options, (k, v) => typeof v === "bigint" ? v.toString(16) : v));
     let loads = 0;

package/dist/types.d.ts

@@ -91,12 +91,12 @@ export type FBO = {
 *
 * @param {boolean} [debug=false] - Enables additional debug logging to the console. Default: false
 * @param {number} [effort=0x8] - Multiplier for dispatching work search. Larger values are not necessarily better since they can quickly overwhelm the GPU. Ignored when validating. Default: 0x8
-* @param {number} [threshold=0xfffffff8] - Minimum value result of `BLAKE2b(nonce||blockhash) << 0x32`. Default: 0xFFFFFFF8
+* @param {bigint|string} [threshold=0xfffffff800000000] - Minimum value result of `BLAKE2b(nonce||blockhash)`. Default: 0xFFFFFFF800000000
 */
 export type NanoPowOptions = {
 	debug?: boolean
 	effort?: number
-	threshold?: bigint | number
+	threshold?: bigint | string
 }
 
 /**
@@ -105,7 +105,7 @@ export type NanoPowOptions = {
 export declare class NanoPowGl {
 	#private
 	/** Drawing buffer width in pixels. */
-	static get size (): number | undefined
+	static get size (): number
 	/**
 	* Constructs canvas, gets WebGL context, initializes buffers, and compiles
 	* shaders.

package/docs/index.js

@@ -0,0 +1,38 @@
+//! SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
+//! SPDX-License-Identifier: GPL-3.0-or-later
+
+export const cliHelp = `Usage: nano-pow [OPTION]... BLOCKHASH...
+Generate work for BLOCKHASH, or multiple work values for BLOCKHASH(es)
+BLOCKHASH is a 64-character hexadecimal string. Multiple blockhashes must be separated by whitespace or line breaks.
+Prints a 16-character hexadecimal work value to standard output. If using --validate, prints 'true' or 'false' to standard output instead.
+
+  -h, --help                  show this dialog
+  -d, --debug                 enable additional logging output
+	-j, --json                  format output as JSON
+  -e, --effort=<value>        increase demand on GPU processing
+  -t, --threshold=<value>     override the minimum threshold value
+  -v, --validate=<value>      check an existing work value instead of searching for one
+
+If validating a nonce, it must be a 16-character hexadecimal value.
+Effort must be a decimal number between 1-32.
+Threshold must be a hexadecimal string between 0-FFFFFFFF.
+
+Report bugs: <bug-nano-pow@zoso.dev>
+Full documentation: <https://www.npmjs.com/package/nano-pow>
+`
+
+export const serverHelp = `Usage: Send POST request to server URL to generate or validate Nano proof-of-work
+
+Generate work for a BLOCKHASH with an optional DIFFICULTY:
+  curl -d '{ action: "work_generate", hash: BLOCKHASH, difficulty?: DIFFICULTY }'
+
+Validate WORK previously calculated for a BLOCKHASH with an optional DIFFICULTY:
+  curl -d '{ action: "work_validate", work: WORK, hash: BLOCKHASH, difficulty?: DIFFICULTY }'
+
+BLOCKHASH is a 64-character hexadecimal string.
+WORK is 16-character hexadecimal string.
+DIFFICULTY is a 16-character hexadecimal string (default: FFFFFFF800000000)
+
+Report bugs: <bug-nano-pow@zoso.dev>
+Full documentation: <https://www.npmjs.com/package/nano-pow>
+`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nano-pow",
-	"version": "3.2.1",
+	"version": "4.0.0",
 	"description": "Proof-of-work generation and validation with WebGPU/WebGL for Nano cryptocurrency.",
 	"keywords": [
 		"nemo",
@@ -45,7 +45,9 @@
 		"url": "git+https://zoso.dev/nano-pow.git"
 	},
 	"scripts": {
-		"build": "rm -rf {dist,types} && tsc && node esbuild.mjs"
+		"build": "rm -rf {dist,types} && tsc && node esbuild.mjs",
+		"start": "mkdir -p logs; node ./dist/bin/server.js > ./logs/nano-pow-server-$(date +%s).log 2>&1 & echo $! > server.pid",
+		"test": "./test/script.sh"
 	},
 	"devDependencies": {
 		"@types/node": "^22.13.11",