feat: add comprehensive sBTC taproot descriptor tests

Add complete test suite for sBTC protocol's two-leaf taproot tree
with deposit (payload_drop) and reclaim (r:older with multi_a)
leaves. Verify structure parsing, P2TR output generation, and
address derivation. Tests demonstrate proper use of fromStringExt
with `drop: true` to enable r:older() in taproot context.

Issue: BTC-3357

Co-authored-by: llm-git <llm-git@ttll.de>

Author: OttoAllmendinger

packages/wasm-utxo/test/sbtc.ts

@@ -0,0 +1,117 @@
+import * as assert from "assert";
+import * as utxolib from "@bitgo/utxo-lib";
+import { Descriptor } from "../js/index.js";
+import type { ExtParamsConfig } from "../js/index.js";
+
+// sBTC protocol uses two taproot script leaves:
+// 1. Deposit leaf: allows the signers to spend with a protocol payload
+// 2. Reclaim leaf: allows the depositors to reclaim after a timelock
+
+const DEPOSIT_LEAF =
+  "c:and_v(payload_drop(" +
+  "0000000000013880051ad206838b7981a116c334e8cb1b950afb73eb54a5" +
+  "),pk_k(c9c2312ca406dcb8eed50b829b5292f5fb3e846db0a556af61cc53834ce75421))";
+
+const RECLAIM_LEAF =
+  "and_v(r:older(1),multi_a(2," +
+  "4d838759b2a74616a2298e0580ca815874f5e5a9d2dd1b2f0203b68c66fc6c1e," +
+  "639779c4b700dc51ece012a0e20325fcafada22a4a122ffaa04d0c0ccae83943," +
+  "d1d6084eac98303e9d28e082bfd9eadf0b8be033e223a17ad01df81bdaa8c7b2))";
+
+const SIGNERS_KEY = "c9c2312ca406dcb8eed50b829b5292f5fb3e846db0a556af61cc53834ce75421";
+
+function getSbtcDescriptor(signersKey: string, depositLeaf: string, reclaimLeaf: string) {
+  return `tr(${signersKey},{${depositLeaf},${reclaimLeaf}})`;
+}
+
+// Types matching the node() structure for the sBTC taproot descriptor
+type DefiniteKey = { Single: string };
+
+type SbtcDepositLeaf = {
+  Check: {
+    AndV: [{ PayloadDrop: string }, { PkK: DefiniteKey }];
+  };
+};
+
+type SbtcReclaimLeaf = {
+  AndV: [{ Drop: { Older: { relLockTime: number } } }, { MultiA: DefiniteKey[] }];
+};
+
+type SbtcDescriptorNode = {
+  Tr: [DefiniteKey, { Tree: [SbtcDepositLeaf, SbtcReclaimLeaf] }];
+};
+
+describe("sBTC taproot descriptor", function () {
+  // Use fromStringExt with { drop: true } to enable r:older() in taproot
+  const descriptor = Descriptor.fromStringExt(
+    getSbtcDescriptor(SIGNERS_KEY, DEPOSIT_LEAF, RECLAIM_LEAF),
+    "definite",
+    { drop: true } satisfies ExtParamsConfig,
+  );
+
+  it("parses successfully with fromStringExt", () => {
+    // Key test: Descriptor.fromStringExt({ drop: true }) handles r:older() with targeted drop permission
+    assert.ok(descriptor, "Descriptor should parse successfully");
+  });
+
+  it("has expected taproot structure", () => {
+    const node = descriptor.node() as SbtcDescriptorNode;
+    // Definite descriptors wrap keys in { Single: "..." }
+    assert.deepStrictEqual(node.Tr[0], { Single: SIGNERS_KEY }, "Should have correct internal key");
+    assert.ok(node.Tr[1].Tree, "Should have taproot tree structure");
+    assert.strictEqual(node.Tr[1].Tree.length, 2, "Should have two leaves");
+  });
+
+  describe("deposit leaf", function () {
+    it("has correct structure with payload_drop", () => {
+      const node = descriptor.node() as SbtcDescriptorNode;
+      const depositLeaf = node.Tr[1].Tree[0];
+
+      assert.deepStrictEqual(depositLeaf, {
+        Check: {
+          AndV: [
+            { PayloadDrop: "0000000000013880051ad206838b7981a116c334e8cb1b950afb73eb54a5" },
+            { PkK: { Single: "c9c2312ca406dcb8eed50b829b5292f5fb3e846db0a556af61cc53834ce75421" } },
+          ],
+        },
+      });
+    });
+  });
+
+  describe("reclaim leaf", function () {
+    it("has correct structure with r:older (Drop wrapper)", () => {
+      const node = descriptor.node() as SbtcDescriptorNode;
+      const reclaimLeaf = node.Tr[1].Tree[1];
+
+      // Verify the r:older pattern creates a Drop wrapper
+      assert.ok(reclaimLeaf.AndV, "Should have AndV structure");
+      assert.ok(reclaimLeaf.AndV[0].Drop, "Should have Drop wrapper for r:older");
+      assert.ok(reclaimLeaf.AndV[0].Drop.Older, "Should contain Older inside Drop");
+      assert.strictEqual(
+        reclaimLeaf.AndV[0].Drop.Older.relLockTime,
+        1,
+        "Should have locktime of 1",
+      );
+
+      // Verify the multi_a is the second part
+      assert.ok(reclaimLeaf.AndV[1].MultiA, "Should have MultiA as second element");
+    });
+  });
+
+  describe("P2TR output", function () {
+    it("produces correct address", () => {
+      const scriptPubkeyBytes = descriptor.scriptPubkey();
+
+      // P2TR scripts are 34 bytes: OP_1 (0x51) + OP_PUSHBYTES_32 (0x20) + 32-byte pubkey
+      assert.strictEqual(scriptPubkeyBytes.length, 34, "Should be 34 bytes");
+      assert.strictEqual(scriptPubkeyBytes[0], 0x51, "Should start with OP_1");
+      assert.strictEqual(scriptPubkeyBytes[1], 0x20, "Should have 32-byte push");
+
+      const addr = utxolib.address.fromOutputScript(
+        Buffer.from(scriptPubkeyBytes) as Buffer<ArrayBufferLike>,
+        utxolib.networks.bitcoin,
+      );
+      assert.strictEqual(addr, "bc1p04m0dcwy53627k03x67wjzfn77x7zu85pmwnz653u4uzpl4qsg9qgp3nqd");
+    });
+  });
+});