@bitcoinerlab/miniscript-policies 1.0.0

package/example.js

@@ -0,0 +1,34 @@
+// To run it: "node ./example.js"
+
+const { compilePolicy, compileMiniscript, ready } = require("./dist/index.js");
+
+(async () => {
+  await ready;
+
+  const policy = "or(and(pk(A),older(8640)),pk(B))";
+
+  const {
+    miniscript,
+    asm: asmFromPolicy,
+    issane: issaneFromPolicy,
+  } = compilePolicy(policy);
+
+  const { asm: asmFromMiniscript, issane: issaneFromMiniscript } =
+    compileMiniscript(miniscript);
+
+  console.assert(asmFromPolicy === asmFromMiniscript, "ERROR: Asm mismatch.");
+  console.assert(
+    issaneFromPolicy === issaneFromMiniscript,
+    "ERROR: issane mismatch.",
+  );
+
+  console.log({
+    miniscript,
+    asm: asmFromMiniscript,
+    issane: issaneFromMiniscript,
+  });
+
+  console.log(
+    compileMiniscript("and_v(v:pk(key),or_b(l:after(100),al:after(200)))"),
+  );
+})();

package/js_bindings.cpp

@@ -0,0 +1,154 @@
+// Initial author: Pieter Wuille
+// Adapted by Jose-Luis Landabaso so that miniscript_compile and miniscript_analyze
+// return issane & issanesublevel
+#include <string>
+
+#include <script/miniscript.h>
+
+#include "compiler.h"
+
+namespace {
+
+using miniscript::operator"" _mst;
+
+void Output(const std::string& str, char* out, int outlen) {
+    int maxlen = std::min<int>(outlen - 1, str.size());
+    memcpy(out, str.c_str(), maxlen);
+    out[maxlen] = 0;
+}
+
+std::string Props(const miniscript::NodeRef<std::string>& node, std::string in) {
+    std::string ret = "<span title=\"type: ";
+    if (node->GetType() == ""_mst) {
+        ret += "[invalid]";
+    } else {
+        if (node->GetType() << "B"_mst) ret += 'B';
+        if (node->GetType() << "V"_mst) ret += 'V';
+        if (node->GetType() << "W"_mst) ret += 'W';
+        if (node->GetType() << "K"_mst) ret += 'K';
+        if (node->GetType() << "z"_mst) ret += 'z';
+        if (node->GetType() << "o"_mst) ret += 'o';
+        if (node->GetType() << "n"_mst) ret += 'n';
+        if (node->GetType() << "d"_mst) ret += 'd';
+        if (node->GetType() << "f"_mst) ret += 'f';
+        if (node->GetType() << "e"_mst) ret += 'e';
+        if (node->GetType() << "m"_mst) ret += 'm';
+        if (node->GetType() << "u"_mst) ret += 'u';
+        if (node->GetType() << "s"_mst) ret += 's';
+        if (node->GetType() << "k"_mst) ret += 'k';
+    }
+    ret += "&#13;scriptlen: " + std::to_string(node->ScriptSize());
+    ret += "&#13;max ops: " + std::to_string(node->GetOps());
+    ret += "&#13;max stack size: " + std::to_string(node->GetStackSize());
+    return std::move(ret) + "\">" + std::move(in) + "</span>";
+}
+
+std::string Analyze(const miniscript::NodeRef<std::string>& node) {
+    switch (node->fragment) {
+        case miniscript::Fragment::PK_K: {
+            return Props(node, "pk_k(" + (*COMPILER_CTX.ToString(node->keys[0])) + ")");
+        }
+        case miniscript::Fragment::PK_H: {
+            return Props(node, "pk_h(" + (*COMPILER_CTX.ToString(node->keys[0])) + ")");
+        }
+        case miniscript::Fragment::MULTI: return Props(node, "multi(" + std::to_string(node->k) + " of " + std::to_string(node->keys.size()) + ")");
+        case miniscript::Fragment::AFTER: return Props(node, "after(" + std::to_string(node->k) + ")");
+        case miniscript::Fragment::OLDER: return Props(node, "older(" + std::to_string(node->k) + ")");
+        case miniscript::Fragment::SHA256: return Props(node, "sha256()");
+        case miniscript::Fragment::RIPEMD160: return Props(node, "ripemd160()");
+        case miniscript::Fragment::HASH256: return Props(node, "hash256()");
+        case miniscript::Fragment::HASH160: return Props(node, "hash160()");
+        case miniscript::Fragment::JUST_0: return Props(node, "false");
+        case miniscript::Fragment::JUST_1: return Props(node, "true");
+        case miniscript::Fragment::WRAP_A: return Props(node, "a:") + " " + Analyze(node->subs[0]);
+        case miniscript::Fragment::WRAP_S: return Props(node, "s:") + " " + Analyze(node->subs[0]);
+        case miniscript::Fragment::WRAP_C: return Props(node, "c:") + " " + Analyze(node->subs[0]);
+        case miniscript::Fragment::WRAP_D: return Props(node, "d:") + " " + Analyze(node->subs[0]);
+        case miniscript::Fragment::WRAP_V: return Props(node, "v:") + " " + Analyze(node->subs[0]);
+        case miniscript::Fragment::WRAP_N: return Props(node, "n:") + " " + Analyze(node->subs[0]);
+        case miniscript::Fragment::WRAP_J: return Props(node, "j:") + " " + Analyze(node->subs[0]);
+        case miniscript::Fragment::AND_V: return Props(node, "and_v") + "<ul style=\"list-style-type: disc;\"><li>" + Analyze(node->subs[0]) + "</li><li>" + Analyze(node->subs[1]) + "</li></ul>";
+        case miniscript::Fragment::AND_B: return Props(node, "and_b") + "<ul style=\"list-style-type: disc;\"><li>" + Analyze(node->subs[0]) + "</li><li>" + Analyze(node->subs[1]) + "</li></ul>";
+        case miniscript::Fragment::OR_B: return Props(node, "or_b") + "<ul style=\"list-style-type: disc;\"><li>" + Analyze(node->subs[0]) + "</li><li>" + Analyze(node->subs[1]) + "</li></ul>";
+        case miniscript::Fragment::OR_C: return Props(node, "or_c") + "<ul style=\"list-style-type: disc;\"><li>" + Analyze(node->subs[0]) + "</li><li>" + Analyze(node->subs[1]) + "</li></ul>";
+        case miniscript::Fragment::OR_D: return Props(node, "or_d") + "<ul style=\"list-style-type: disc;\"><li>" + Analyze(node->subs[0]) + "</li><li>" + Analyze(node->subs[1]) + "</li></ul>";
+        case miniscript::Fragment::OR_I: return Props(node, "or_i") + "<ul style=\"list-style-type: disc;\"><li>" + Analyze(node->subs[0]) + "</li><li>" + Analyze(node->subs[1]) + "</li></ul>";
+        case miniscript::Fragment::ANDOR: return Props(node, "andor [or]") + "<ul style=\"list-style-type: disc;\"><li>andor [and]<ul style=\"list-style-type: disc;\"><li>" + Analyze(node->subs[0]) + "</li><li>" + Analyze(node->subs[1]) + "</li></ul></li><li>" + Analyze(node->subs[2]) + "</li></ul>";
+        case miniscript::Fragment::THRESH: {
+             auto ret = Props(node, "thresh(" + std::to_string(node->k) + " of " + std::to_string(node->subs.size()) + ")") + "<ul style=\"list-style-type: disc;\">";
+             for (const auto& sub : node->subs) {
+                 ret += "<li>" + Analyze(sub) + "</li>";
+             }
+             return std::move(ret) + "</ul>";
+        }
+    }
+}
+
+}
+
+extern "C" {
+
+void miniscript_compile(const char* desc, char* msout, int msoutlen, char* costout, int costoutlen, char* asmout, int asmoutlen, char* issane, int issanelen, char* issanesublevel, int issanesublevellen) {
+    try {
+        std::string str(desc);
+        str.erase(str.find_last_not_of(" \n\r\t") + 1);
+        miniscript::NodeRef<std::string> ret;
+        double avgcost;
+        if (!Compile(Expand(str), ret, avgcost)) {
+            Output("[compile error]", msout, msoutlen);
+            Output("[compile error]", costout, costoutlen);
+            Output("[compile error]", asmout, asmoutlen);
+            return;
+        }
+        Output(Abbreviate(*(ret->ToString(COMPILER_CTX))), msout, msoutlen);
+        std::string coststr = "<ul><li>Script: " + std::to_string(ret->ScriptSize()) + " WU</li><li>Input: " + std::to_string(avgcost) + " WU</li><li>Total: " + std::to_string(ret->ScriptSize() + avgcost) + " WU</li></ul>";
+        Output(coststr, costout, costoutlen);
+        Output(Disassemble(ret->ToScript(COMPILER_CTX)), asmout, asmoutlen);
+        if (ret->IsSane()) {
+            Output("true", issanesublevel, issanesublevellen);
+        } else {
+            Output("false", issanesublevel, issanesublevellen);
+        }
+        if (ret->IsValidTopLevel()) {
+            Output("true", issane, issanelen);
+        } else {
+            Output("false", issane, issanelen);
+        }
+    } catch (const std::exception& e) {
+        Output("[exception: " + std::string(e.what()) + "]", msout, msoutlen);
+        Output("", costout, costoutlen);
+        Output("", asmout, asmoutlen);
+    }
+}
+
+void miniscript_analyze(const char* ms, char* costout, int costoutlen, char* asmout, int asmoutlen, char* issane, int issanelen, char* issanesublevel, int issanesublevellen) {
+    try {
+        std::string str(ms);
+        str.erase(str.find_last_not_of(" \n\r\t") + 1);
+        miniscript::NodeRef<std::string> ret;
+        ret = miniscript::FromString(Expand(str), COMPILER_CTX);
+        if (!ret || !ret->IsValidTopLevel()) {
+            Output("[analysis error]", costout, costoutlen);
+            Output("[analysis error]", asmout, asmoutlen);
+            return;
+        }
+        std::string coststr = "Size: " + std::to_string(ret->ScriptSize()) + " bytes script<ul><li>" + Analyze(ret) + "</li></ul>";
+        Output(coststr, costout, costoutlen);
+        Output(Disassemble(ret->ToScript(COMPILER_CTX)), asmout, asmoutlen);
+        if (ret->IsSane()) {
+            Output("true", issanesublevel, issanesublevellen);
+        } else {
+            Output("false", issanesublevel, issanesublevellen);
+        }
+        if (ret->IsValidTopLevel()) {
+            Output("true", issane, issanelen);
+        } else {
+            Output("false", issane, issanelen);
+        }
+    } catch (const std::exception& e) {
+        Output("[exception: " + std::string(e.what()) + "]", costout, costoutlen);
+        Output("", asmout, asmoutlen);
+    }
+}
+
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@bitcoinerlab/miniscript-policies",
+  "author": "Jose-Luis Landabaso <landabaso@gmail.com>",
+  "license": "MIT",
+  "keywords": [
+    "miniscript",
+    "policy",
+    "compiler",
+    "bitcoin",
+    "asm",
+    "descriptors"
+  ],
+  "homepage": "https://bitcoinerlab.com/modules/miniscript",
+  "version": "1.0.0",
+  "description": "Bitcoin Miniscript policy compiler",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "build": "rollup -c --bundleConfigAsCjs",
+    "build:prod": "NODE_ENV=production rollup -c --bundleConfigAsCjs",
+    "prepublishOnly": "npm test",
+    "test": "make clean && make && npm run build:prod && jest"
+  },
+  "COMMENT_babel": "Babel plugins are are only needed for the jest testing environment. Jest needs to use commonjs. Also, jest cannot handle ESM converted code, since it uses 'import.meta.url'. See src/bindings.js. babel-plugin-transform-import-meta fixes it.",
+  "babel": {
+    "env": {
+      "test": {
+        "plugins": [
+          "@babel/plugin-transform-modules-commonjs",
+          "babel-plugin-transform-import-meta"
+        ]
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bitcoinerlab/miniscript-policies.git"
+  },
+  "devDependencies": {
+    "@babel/plugin-transform-modules-commonjs": "^7.19.6",
+    "@bitcoinerlab/configs": "^2.0.0",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "babel-plugin-transform-import-meta": "^2.2.0",
+    "rollup": "^3.29.5"
+  },
+  "dependencies": {
+    "bip68": "^1.0.4"
+  },
+  "bugs": {
+    "url": "https://github.com/bitcoinerlab/miniscript-policies/issues"
+  }
+}

package/patches/uppercase-h.patch

@@ -0,0 +1,11 @@
+--- compiler.cpp.bak	2026-01-30 13:12:43
++++ compiler.cpp	2026-01-30 13:12:54
+@@ -848,7 +848,7 @@
+         }
+         if (data.size() == 20) {
+             if (data == std::vector<unsigned char>(20, 0x99)) {
+-                ret += "<h>";
++                ret += "<H>";
+             } else if (data[0] == 'P' && data[1] == 'K' && data[2] == 'h') {
+                 while (data.size() && data.back() == 0) data.pop_back();
+                 ret += "<HASH160(" + std::string((const char*)data.data() + 3, data.size() - 3) + ")>";

package/rollup.config.js

@@ -0,0 +1,13 @@
+
+import commonjs from "@rollup/plugin-commonjs";
+
+export default {
+  input: "./src/index.js",
+  output: {
+    file: "./dist/index.js",
+    format: "cjs",
+  },
+  plugins: [commonjs()],
+  // Tell Rollup not to bundle dependencies listed in package.json
+  external: [...Object.keys(require("./package.json").dependencies || {})],
+};

package/src/index.js

@@ -0,0 +1,5 @@
+// Distributed under the MIT software license
+
+import { compilePolicy, compileMiniscript, ready } from './miniscript.js';
+
+export { compilePolicy, compileMiniscript, ready };

package/src/miniscript.js

@@ -0,0 +1,149 @@
+// Initial author: Pieter Wuille ( https://github.com/sipa/miniscript/blob/master/index.html)
+// Adapted by Jose-Luis Landabaso - https://bitcoinerlab.com:
+//  compilePolicy, compileMiniscript with issane, issanesublevel and cleanAsm
+
+import bindings from './bindings.js';
+
+const cleanAsm = asm =>
+  asm
+    .trim()
+    .replace(/\n/g, ' ')
+    .replace(/ +(?= )/g, '');
+
+let Module;
+let em_miniscript_compile;
+let em_miniscript_analyze;
+let modulePromise;
+
+const initModule = () => {
+  if (!modulePromise) {
+    modulePromise = Promise.resolve(bindings()).then(resolved => {
+      Module = resolved;
+      em_miniscript_compile = Module.cwrap('miniscript_compile', 'none', [
+        'string',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number',
+        'number'
+      ]);
+      em_miniscript_analyze = Module.cwrap('miniscript_analyze', 'none', [
+        'string',
+        'number',
+        'number',
+        'number',
+        'number'
+      ]);
+      return Module;
+    });
+  }
+
+  return modulePromise;
+};
+
+export const ready = initModule();
+
+const ensureReady = () => {
+  if (!Module || !em_miniscript_compile || !em_miniscript_analyze) {
+    throw new Error('Miniscript bindings not ready. Await ready before calling compile functions.');
+  }
+};
+
+/**
+ * @typedef {Object} CompilePolicyResult
+ * @property {string} miniscript - The compiled miniscript expression.
+ * @property {string} asm - The compiled miniscript as Bitcoin asm code.
+ * @property {boolean} issane - Whether the miniscript is sane at the top level.
+ * @property {boolean} issanesublevel - Whether the miniscript is sane at the sublevel.
+ */
+
+/**
+ * @typedef {Object} CompileMiniscriptResult
+ * @property {string} asm - The Bitcoin asm code of the compiled miniscript expression.
+ * @property {boolean} issane - Whether the miniscript is sane at the top level.
+ * @property {boolean} issanesublevel - Whether the miniscript is sane at the sublevel.
+ */
+
+
+/**
+ * Compiles a miniscript policy into a miniscript expression (if possible).
+ * @function
+ *
+ * @param {string} policy - The miniscript policy to compile.
+ * @returns {CompilePolicyResult}
+ */
+export const compilePolicy = policy => {
+  ensureReady();
+  const miniscript = Module._malloc(10000);
+  const cost = Module._malloc(500);
+  const asm = Module._malloc(100000);
+  const issane = Module._malloc(10);
+  const issanesublevel = Module._malloc(10);
+  em_miniscript_compile(
+    policy,
+    miniscript,
+    10000,
+    cost,
+    500,
+    asm,
+    100000,
+    issane,
+    10,
+    issanesublevel,
+    10
+  );
+  const result = {
+    miniscript: Module.UTF8ToString(miniscript),
+    asm: cleanAsm(Module.UTF8ToString(asm)),
+    issane: Module.UTF8ToString(issane) === 'true' ? true : false,
+    issanesublevel:
+      Module.UTF8ToString(issanesublevel) === 'true' ? true : false
+  };
+  Module._free(miniscript);
+  Module._free(cost);
+  Module._free(asm);
+  Module._free(issane);
+  Module._free(issanesublevel);
+
+  return result;
+};
+
+/**
+ * Compiles a miniscript expression and returns its asm code.
+ * @function
+ *
+ * @param {string} miniscript - A miniscript expression.
+ * @returns {CompileMiniscriptResult}
+ */
+export const compileMiniscript = miniscript => {
+  ensureReady();
+  const analysis = Module._malloc(50000);
+  const asm = Module._malloc(100000);
+  const issane = Module._malloc(10);
+  const issanesublevel = Module._malloc(10);
+  em_miniscript_analyze(
+    miniscript,
+    analysis,
+    50000,
+    asm,
+    100000,
+    issane,
+    10,
+    issanesublevel,
+    10
+  );
+  const result_asm = Module.UTF8ToString(asm);
+  const result_issane = Module.UTF8ToString(issane);
+  const result_issanesublebel = Module.UTF8ToString(issanesublevel);
+  Module._free(analysis);
+  Module._free(asm);
+  Module._free(issane);
+  Module._free(issanesublevel);
+
+  return {
+    asm: cleanAsm(result_asm),
+    issane: result_issane === 'true' ? true : false,
+    issanesublevel: result_issanesublebel === 'true' ? true : false
+  };
+};