feat(wasm-utxo): add backwards-compatible RecursiveTapTree

Implements a RecursiveTapTree type to maintain compatibility with
previous API after the upstream rust-miniscript library removed the
recursive tap tree structure in favor of a flat representation.

Issue: BTC-2656

Co-authored-by: llm-git <[email protected]>

Author: OttoAllmendinger

packages/wasm-utxo/src/wasm/mod.rs

@@ -5,6 +5,7 @@ mod ecpair;
 mod fixed_script_wallet;
 mod miniscript;
 mod psbt;
+mod recursive_tap_tree;
 mod replay_protection;
 mod try_from_js_value;
 mod try_into_js_value;

packages/wasm-utxo/src/wasm/recursive_tap_tree.rs

@@ -0,0 +1,66 @@
+use miniscript::descriptor::TapTree;
+use miniscript::{Miniscript, MiniscriptKey};
+
+use crate::error::WasmUtxoError;
+
+/// The recursive tap tree was removed from rust-miniscript in https://github.com/rust-bitcoin/rust-miniscript/pull/808
+/// Our API is somewhat dependent on it and providing backwards compatibility is easier than rewriting everything.
+pub enum RecursiveTapTree<Pk: MiniscriptKey> {
+    Tree {
+        left: Box<RecursiveTapTree<Pk>>,
+        right: Box<RecursiveTapTree<Pk>>,
+    },
+    Leaf(Miniscript<Pk, miniscript::Tap>),
+}
+
+impl<Pk: MiniscriptKey + Clone> TryFrom<&TapTree<Pk>> for RecursiveTapTree<Pk> {
+    type Error = WasmUtxoError;
+
+    fn try_from(tree: &TapTree<Pk>) -> Result<Self, Self::Error> {
+        use std::sync::Arc;
+
+        // Collect leaves with depths (miniscript() returns Arc<Miniscript>)
+        let leaves: Vec<(u8, Arc<Miniscript<Pk, miniscript::Tap>>)> = tree
+            .leaves()
+            .map(|item| (item.depth(), item.miniscript().clone()))
+            .collect();
+
+        if leaves.is_empty() {
+            return Err(WasmUtxoError::new("Empty tap tree"));
+        }
+
+        // Stack-based reconstruction: process leaves left-to-right,
+        // combining siblings at the same depth into Tree nodes
+        let mut stack: Vec<(u8, RecursiveTapTree<Pk>)> = Vec::new();
+
+        for (depth, ms) in leaves {
+            // Clone the Miniscript from the Arc
+            stack.push((depth, RecursiveTapTree::Leaf((*ms).clone())));
+
+            // Combine nodes at the same depth
+            while stack.len() >= 2 {
+                let len = stack.len();
+                if stack[len - 2].0 != stack[len - 1].0 {
+                    break;
+                }
+
+                let (_, right) = stack.pop().unwrap();
+                let (d, left) = stack.pop().unwrap();
+
+                stack.push((
+                    d - 1,
+                    RecursiveTapTree::Tree {
+                        left: Box::new(left),
+                        right: Box::new(right),
+                    },
+                ));
+            }
+        }
+
+        if stack.len() != 1 {
+            return Err(WasmUtxoError::new("Invalid tap tree structure"));
+        }
+
+        Ok(stack.pop().unwrap().1)
+    }
+}

packages/wasm-utxo/src/wasm/try_into_js_value.rs

@@ -243,19 +243,23 @@ impl<Pk: MiniscriptKey + TryIntoJsValue> TryIntoJsValue for Tr<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + TryIntoJsValue> TryIntoJsValue for TapTree<Pk> {
+use super::recursive_tap_tree::RecursiveTapTree;
+
+impl<Pk: MiniscriptKey + TryIntoJsValue> TryIntoJsValue for RecursiveTapTree<Pk> {
     fn try_to_js_value(&self) -> Result<JsValue, WasmUtxoError> {
-        // TapTree is now a flat representation of leaves with depths
-        // Convert to an array of {depth, miniscript} objects
-        let arr = Array::new();
-        for item in self.leaves() {
-            let leaf_obj = js_obj!(
-                "depth" => item.depth() as u32,
-                "miniscript" => item.miniscript()
-            )?;
-            arr.push(&leaf_obj);
+        match self {
+            RecursiveTapTree::Tree { left, right } => js_obj!("Tree" => js_arr!(left, right)),
+            RecursiveTapTree::Leaf(ms) => ms.try_to_js_value(),
         }
-        Ok(arr.into())
+    }
+}
+
+impl<Pk: MiniscriptKey + TryIntoJsValue> TryIntoJsValue for TapTree<Pk>
+where
+    Pk: Clone,
+{
+    fn try_to_js_value(&self) -> Result<JsValue, WasmUtxoError> {
+        RecursiveTapTree::try_from(self)?.try_to_js_value()
     }
 }
 

packages/wasm-utxo/test/fixtures/2.json

@@ -1,11 +1,11 @@
 {
-  "descriptor": "pkh(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)#wf36a0pg",
+  "descriptor": "pkh([deadbeef/1/2'/3/4']03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)#v0p5w8jl",
   "wasmNode": {
     "Pkh": {
-      "Single": "03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd"
+      "Single": "[deadbeef/1/2'/3/4']03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd"
     }
   },
   "ast": {
-    "pkh": "03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd"
+    "pkh": "[deadbeef/1/2'/3/4']03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd"
   }
 }