@bitcoinerlab/miniscript-policies 1.0.0 → 1.1.0

package/README.md

@@ -1,26 +1,154 @@
 # Miniscript Policies
 
-This package exposes the reference C++ Miniscript policy compiler in JavaScript
-via Emscripten. It is a companion to https://github.com/bitcoinerlab/miniscript,
-which does the heavy lifting for compilation and satisfactions.
+`@bitcoinerlab/miniscript-policies` exposes the reference C++ Miniscript policy
+compiler from [`sipa/miniscript`](https://github.com/sipa/miniscript) in
+JavaScript via Emscripten.
 
-Use this package when you need to compile policies into Miniscript expressions
-for P2WSH.
+It is designed for projects that want to compile human-friendly policies (like
+`or(and(pk(A),older(8640)),pk(B))`) into Miniscript expressions.
 
-## Usage
+Upstream Miniscript reference docs: https://bitcoin.sipa.be/miniscript/
+
+## What this package provides
+
+- `compilePolicy(policy)`: reference policy compiler output (P2WSH-oriented)
+- `compilePolicyTaproot(policy)`: Taproot-focused policy compiler shim
+- `ready`: promise you must await before using compiler functions
+
+For Miniscript parsing/analysis/satisfier features, use
+[`@bitcoinerlab/miniscript`](https://github.com/bitcoinerlab/miniscript).
+
+## How Taproot support works
+
+`compilePolicyTaproot` is a strict shim built on top of the same reference
+compiler:
+
+1. Compile policy with the reference C++ compiler.
+2. Rewrite `multi(...)` to `multi_a(...)`.
+3. Validate the rewritten expression in tapscript context using
+   `@bitcoinerlab/miniscript`.
+4. If reference compilation fails, forward the same reference error string
+   (for example `"[compile error]"` or `"[exception: ...]"`) with
+   `issane=false`.
+5. If rewrite/validation fails, return a Taproot-specific error string with
+   prefix `"[taproot rewrite error]"` (or `"[taproot rewrite exception]"`)
+   and `issane=false`.
+
+This gives a practical policy-to-miniscript path for Taproot while preserving
+strict safety checks.
+
+## Installation
+
+```bash
+npm install @bitcoinerlab/miniscript-policies
+```
+
+## Quick start
 
 ```javascript
-import { compilePolicy, ready } from '@bitcoinerlab/miniscript-policies';
+import {
+  compilePolicy,
+  compilePolicyTaproot,
+  ready
+} from '@bitcoinerlab/miniscript-policies';
 
 await ready;
+
 const policy = 'or(and(pk(A),older(8640)),pk(B))';
-const result = compilePolicy(policy);
-console.log(result.miniscript);
+
+// Reference compiler (includes asm)
+const p2wsh = compilePolicy(policy);
+if (!p2wsh.issane) {
+  console.warn('Policy result is not sane for P2WSH:', p2wsh.miniscript);
+} else {
+  console.log(p2wsh.miniscript);
+}
+
+// Taproot shim (no asm)
+const taproot = compilePolicyTaproot('thresh(2,pk(A),pk(B),pk(C))');
+if (!taproot.issane) {
+  console.warn('Policy result is not sane for tapscript:', taproot.miniscript);
+} else {
+  console.log(taproot.miniscript); // multi_a(2,A,B,C)
+}
+```
+
+## API
+
+### `compilePolicy(policy: string)`
+
+Returns:
+
+```ts
+{
+  miniscript: string;
+  asm: string;
+  issane: boolean;
+  issanesublevel: boolean;
+}
+```
+
+Notes:
+
+- This follows the reference compiler behavior from
+  [`sipa/miniscript`](https://github.com/sipa/miniscript).
+- `asm`, `issane`, and `issanesublevel` are computed by the bundled C++
+  reference implementation and are exposed for informational/compatibility
+  purposes.
+- On failure, `miniscript` and `asm` are `"[compile error]"`.
+
+### `compilePolicyTaproot(policy: string)`
+
+Returns:
+
+```ts
+{
+  miniscript: string;
+  issane: boolean;
+}
 ```
 
+Notes:
+
+- Same result shape style as `compilePolicy`, but without `asm`.
+- Recommended success check is `issane`.
+- On failure, `issane` is `false` and `miniscript` is an error string:
+
+```ts
+{
+  miniscript:
+    | '[compile error]'
+    | `[exception: ...]`
+    | `[taproot rewrite error] ...`
+    | `[taproot rewrite exception] ...`;
+  issane: false;
+}
+```
+
+### `ready: Promise<void>`
+
+Await this once before calling any compiler function.
+
+## Related package
+
+If you need Miniscript analysis, parsing, satisfier, or tapscript checks beyond
+policy-to-miniscript compilation, use
+[`@bitcoinerlab/miniscript`](https://github.com/bitcoinerlab/miniscript).
+
+For application-level validation in both P2WSH and Taproot contexts, prefer
+using `@bitcoinerlab/miniscript` directly. In this package, the reference
+`asm`/sanity fields are returned as informational outputs.
+
+## Upstream credit
+
+This package is built on top of Pieter Wuille's upstream Miniscript work:
+
+- https://github.com/sipa/miniscript
+- https://bitcoin.sipa.be/miniscript/
+
 ## Build
 
-This package uses Emscripten. Build with:
+This package uses Emscripten.
 
 ```bash
 make clean && make

package/dist/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var miniscript = require('@bitcoinerlab/miniscript');
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -52,7 +54,7 @@ var bindings = /*@__PURE__*/getDefaultExportFromCjs(bindingsExports);
 
 // 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
+//  compilePolicy and compilePolicyTaproot with sanity flags
 
 
 const cleanAsm = asm =>
@@ -63,7 +65,6 @@ const cleanAsm = asm =>
 
 let Module;
 let em_miniscript_compile;
-let em_miniscript_analyze;
 let modulePromise;
 
 const initModule = () => {
@@ -79,13 +80,6 @@ const initModule = () => {
         'number',
         'number'
       ]);
-      em_miniscript_analyze = Module.cwrap('miniscript_analyze', 'none', [
-        'string',
-        'number',
-        'number',
-        'number',
-        'number'
-      ]);
       return Module;
     });
   }
@@ -96,7 +90,7 @@ const initModule = () => {
 const ready = initModule();
 
 const ensureReady = () => {
-  if (!Module || !em_miniscript_compile || !em_miniscript_analyze) {
+  if (!Module || !em_miniscript_compile) {
     throw new Error('Miniscript bindings not ready. Await ready before calling compile functions.');
   }
 };
@@ -110,13 +104,11 @@ const ensureReady = () => {
  */
 
 /**
- * @typedef {Object} CompileMiniscriptResult
- * @property {string} asm - The Bitcoin asm code of the compiled miniscript expression.
+ * @typedef {Object} CompilePolicyTaprootResult
+ * @property {string} miniscript - Rewritten tapscript miniscript, or an error marker string.
  * @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
@@ -160,45 +152,69 @@ const compilePolicy = policy => {
   return result;
 };
 
+const isCompileFailure = miniscript =>
+  typeof miniscript !== 'string' ||
+  miniscript === '[compile error]' ||
+  miniscript.startsWith('[exception:');
+
+const rewriteForTapscript = miniscript => miniscript.replace(/\bmulti\(/g, 'multi_a(');
+const taprootRewriteError = message => `[taproot rewrite error] ${message}`;
+const taprootRewriteException = message => `[taproot rewrite exception] ${message}`;
+
 /**
- * Compiles a miniscript expression and returns its asm code.
- * @function
+ * Compiles a miniscript policy into a tapscript miniscript expression.
+ *
+ * Strict mode behavior:
+ * 1) compile with the C++ policy compiler
+ * 2) rewrite multi() to multi_a()
+ * 3) validate rewritten miniscript under tapscript rules
  *
- * @param {string} miniscript - A miniscript expression.
- * @returns {CompileMiniscriptResult}
+ * @param {string} policy - The miniscript policy to compile.
+ * @returns {CompilePolicyTaprootResult}
  */
-const compileMiniscript = miniscript => {
+const compilePolicyTaproot = policy => {
   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
-  };
+  const base = compilePolicy(policy);
+
+  if (isCompileFailure(base.miniscript)) {
+    return {
+      miniscript:
+        typeof base.miniscript === 'string' ? base.miniscript : '[compile error]',
+      issane: false
+    };
+  }
+
+  const miniscript$1 = rewriteForTapscript(base.miniscript);
+
+  try {
+    const analysis = miniscript.analyzeMiniscript(miniscript$1, { tapscript: true });
+    const isValidAndSane = analysis.valid && analysis.issane && analysis.issanesublevel;
+
+    if (!isValidAndSane) {
+      return {
+        miniscript: taprootRewriteError(
+          analysis.error ||
+            'multi() to multi_a() rewrite produced miniscript that is not valid/sane in tapscript context.'
+        ),
+        issane: false
+      };
+    }
+
+    return {
+      miniscript: miniscript$1,
+      issane: analysis.issane
+    };
+  } catch (error) {
+    return {
+      miniscript: taprootRewriteException(
+        error instanceof Error ? error.message : String(error)
+      ),
+      issane: false
+    };
+  }
 };
 
-exports.compileMiniscript = compileMiniscript;
 exports.compilePolicy = compilePolicy;
+exports.compilePolicyTaproot = compilePolicyTaproot;
 exports.ready = ready;

package/package.json

@@ -11,10 +11,14 @@
     "descriptors"
   ],
   "homepage": "https://bitcoinerlab.com/modules/miniscript",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Bitcoin Miniscript policy compiler",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
   "scripts": {
     "build": "rollup -c --bundleConfigAsCjs",
     "build:prod": "NODE_ENV=production rollup -c --bundleConfigAsCjs",
@@ -44,6 +48,7 @@
     "rollup": "^3.29.5"
   },
   "dependencies": {
+    "@bitcoinerlab/miniscript": "^2.0.0",
     "bip68": "^1.0.4"
   },
   "bugs": {

package/types/index.d.ts

@@ -1,14 +1,17 @@
-export declare const compilePolicy: (miniscript: string) => {
+export declare const compilePolicy: (policy: string) => {
   miniscript: string;
   asm: string;
   issane: boolean;
   issanesublevel: boolean;
 };
 
-export declare const compileMiniscript: (miniscript: string) => {
-  asm: string;
+export type CompilePolicyTaprootResult = {
+  miniscript: string;
   issane: boolean;
-  issanesublevel: boolean;
 };
 
+export declare const compilePolicyTaproot: (
+  policy: string
+) => CompilePolicyTaprootResult;
+
 export declare const ready: Promise<void>;

package/Makefile

@@ -1,14 +0,0 @@
-MINISCRIPT_COMMIT ?= 6806dfb15a1fafabf7dd28aae3c9d2bc49db01f1
-# Pinned miniscript commit: "Merge sipa/miniscript#133: Hash clarifications"
-HEADERS := miniscript/bitcoin/util/vector.h miniscript/bitcoin/util/strencodings.h miniscript/bitcoin/span.h miniscript/bitcoin/util/spanparsing.h miniscript/bitcoin/script/script.h miniscript/bitcoin/script/miniscript.h miniscript/compiler.h miniscript/bitcoin/crypto/common.h miniscript/bitcoin/serialize.h miniscript/bitcoin/prevector.h miniscript/bitcoin/compat/endian.h miniscript/bitcoin/compat/byteswap.h miniscript/bitcoin/attributes.h miniscript/bitcoin/tinyformat.h miniscript/bitcoin/primitives/transaction.h
-SOURCES := miniscript/bitcoin/util/strencodings.cpp miniscript/bitcoin/util/spanparsing.cpp miniscript/bitcoin/script/script.cpp miniscript/bitcoin/script/miniscript.cpp miniscript/compiler.cpp
-src/bindings.js: miniscript $(HEADERS) $(SOURCES) miniscript/js_bindings.cpp
-	em++ -O3 -g0 -Wall -std=c++17 -fno-rtti -flto -Iminiscript/bitcoin $(SOURCES) miniscript/js_bindings.cpp -s WASM=0 -s EXPORT_ES6=0 --memory-init-file 0 -s MODULARIZE=1 -s MALLOC=emmalloc -s WASM_ASYNC_COMPILATION=0 -s FILESYSTEM=0 -s ENVIRONMENT=web -s DISABLE_EXCEPTION_CATCHING=0 -s EXPORTED_FUNCTIONS='["_miniscript_compile","_miniscript_analyze","_malloc","_free"]' -s EXPORTED_RUNTIME_METHODS='["cwrap","UTF8ToString"]' -o src/bindings.js
-miniscript:
-	git clone https://github.com/sipa/miniscript
-	git -C miniscript reset --hard $(MINISCRIPT_COMMIT)
-	#Patch: https://github.com/sipa/miniscript/pull/132
-	patch -p0 miniscript/compiler.cpp < patches/uppercase-h.patch
-	cp js_bindings.cpp miniscript/
-clean:
-	rm -rf miniscript src/bindings.js

package/example.js

@@ -1,34 +0,0 @@
-// 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

@@ -1,154 +0,0 @@
-// 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/patches/uppercase-h.patch

@@ -1,11 +0,0 @@
---- 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

@@ -1,13 +0,0 @@
-
-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

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