feat: add P2MR Merkle tree, WASM bindings, and BIP-360 spec tests

Add core P2MR tree construction module with WASM bindings and
comprehensive tests against BIP-360 specification test vectors.

Rust core (src/p2mr/mod.rs):
- Tagged hash computation (TapLeaf, TapBranch per BIP-341)
- Script tree building with DFS traversal and per-leaf control blocks
- Control block generation (leaf_version | 0x01 parity) and verification
- Merkle proof verification against expected root

WASM bindings (src/wasm/p2mr.rs):
- P2mrNamespace with computeLeafHash, computeBranchHash, buildTree,
  buildScriptPubkey, verifyControlBlock
- Uses wasm-utxo TryIntoJsValue/get_field pattern (not serde_wasm_bindgen)
- Tree deserialization: leaf = {script, leafVersion?}, branch = [left, right]

TypeScript (js/p2mr.ts):
- Typed wrapper with ScriptTreeNode, P2mrLeafInfo, P2mrTreeInfo types

Tests:
- Fixture-driven tests against all 8 BIP-360 p2mr_construction vectors

BTC-3241

Author: lcovar

packages/wasm-utxo/js/p2mr.ts

@@ -0,0 +1,90 @@
+/**
+ * P2MR (Pay-to-Merkle-Root) tree construction and verification (BIP-360)
+ *
+ * This module provides functions for building P2MR script trees,
+ * computing leaf/branch hashes, and verifying control blocks.
+ */
+
+import { P2mrNamespace } from "./wasm/wasm_utxo.js";
+
+/** A leaf node in a P2MR script tree */
+export type ScriptTreeLeaf = {
+  /** The compiled script bytes */
+  script: Uint8Array;
+  /** Leaf version (defaults to 0xc0 TapScript) */
+  leafVersion?: number;
+};
+
+/** A P2MR script tree node: either a leaf or a branch [left, right] */
+export type ScriptTreeNode = ScriptTreeLeaf | [ScriptTreeNode, ScriptTreeNode];
+
+/** Per-leaf spending info returned by buildTree */
+export type P2mrLeafInfo = {
+  leafHash: Uint8Array;
+  controlBlock: Uint8Array;
+};
+
+/** Result of building a P2MR tree */
+export type P2mrTreeInfo = {
+  merkleRoot: Uint8Array;
+  leaves: P2mrLeafInfo[];
+};
+
+/**
+ * Compute the TapLeafHash for a script.
+ *
+ * @param script - The script bytes
+ * @param leafVersion - Leaf version (defaults to 0xc0 TapScript)
+ * @returns 32-byte leaf hash
+ */
+export function computeLeafHash(script: Uint8Array, leafVersion?: number): Uint8Array {
+  return P2mrNamespace.computeLeafHash(script, leafVersion ?? undefined);
+}
+
+/**
+ * Compute the TapBranchHash from two 32-byte hashes.
+ *
+ * @param a - First 32-byte hash
+ * @param b - Second 32-byte hash
+ * @returns 32-byte branch hash
+ */
+export function computeBranchHash(a: Uint8Array, b: Uint8Array): Uint8Array {
+  return P2mrNamespace.computeBranchHash(a, b);
+}
+
+/**
+ * Build a P2MR tree from a script tree definition.
+ *
+ * @param tree - A script tree: either a leaf `{ script, leafVersion? }`
+ *   or a branch `[left, right]` where each side is another tree node.
+ * @returns The merkle root and per-leaf spending info (leaf hash + control block)
+ */
+export function buildTree(tree: ScriptTreeNode): P2mrTreeInfo {
+  return P2mrNamespace.buildTree(tree) as P2mrTreeInfo;
+}
+
+/**
+ * Build the 34-byte P2MR scriptPubKey from a 32-byte Merkle root.
+ *
+ * @param merkleRoot - 32-byte merkle root
+ * @returns 34-byte scriptPubKey (OP_2 + OP_PUSHBYTES_32 + root)
+ */
+export function buildScriptPubkey(merkleRoot: Uint8Array): Uint8Array {
+  return P2mrNamespace.buildScriptPubkey(merkleRoot);
+}
+
+/**
+ * Verify a P2MR control block against a leaf hash and expected merkle root.
+ *
+ * @param leafHash - 32-byte leaf hash
+ * @param controlBlock - The control block bytes
+ * @param expectedRoot - 32-byte expected merkle root
+ * @returns True if the control block is valid
+ */
+export function verifyControlBlock(
+  leafHash: Uint8Array,
+  controlBlock: Uint8Array,
+  expectedRoot: Uint8Array,
+): boolean {
+  return P2mrNamespace.verifyControlBlock(leafHash, controlBlock, expectedRoot);
+}

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

@@ -4969,9 +4969,9 @@ mod tests {
             }
 
             // If both have non_witness_utxo, compare the relevant output
-            if orig.non_witness_utxo.is_some() && recon.non_witness_utxo.is_some() {
-                let orig_tx = orig.non_witness_utxo.as_ref().unwrap();
-                let recon_tx = recon.non_witness_utxo.as_ref().unwrap();
+            if let (Some(orig_tx), Some(recon_tx)) =
+                (&orig.non_witness_utxo, &recon.non_witness_utxo)
+            {
                 let vout = original_tx.input[idx].previous_output.vout as usize;
                 assert_eq!(
                     orig_tx.output.get(vout),

packages/wasm-utxo/src/lib.rs

@@ -8,6 +8,7 @@ pub mod inscriptions;
 pub mod inspect;
 pub mod message;
 mod networks;
+pub mod p2mr;
 pub mod paygo;
 pub mod psbt_ops;
 #[cfg(test)]