bitcoind-tests: Add integration test for Plan::satisfy() with P2WSH

Add test_plan_satisfy() which verifies that Plan::satisfy() correctly
constructs witness and script_sig for P2WSH descriptors by:
- Creating a Plan from the descriptor
- Calling plan.satisfy() directly (not using PSBT finalization)
- Manually setting witness/script_sig on the transaction
- Broadcasting to Bitcoin Core and verifying it gets mined

This is a regression test for #896 that exercises the exact code path
that was fixed.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: evanlinjin

bitcoind-tests/tests/setup/test_util.rs

@@ -25,8 +25,7 @@ use bitcoin::hex::DisplayHex;
 use bitcoin::secp256k1;
 use miniscript::descriptor::{SinglePub, SinglePubKey};
 use miniscript::{
-    bitcoin, hash256, Descriptor, DescriptorPublicKey, Error, Miniscript, ScriptContext,
-    Translator,
+    bitcoin, hash256, Descriptor, DescriptorPublicKey, Error, Miniscript, ScriptContext, Translator,
 };
 use rand::RngCore;
 use secp256k1::XOnlyPublicKey;

bitcoind-tests/tests/test_desc.rs

@@ -5,6 +5,7 @@
 //!
 
 use std::collections::BTreeMap;
+use std::str::FromStr;
 use std::{error, fmt};
 
 use actual_rand as rand;
@@ -168,16 +169,19 @@ pub fn test_desc_satisfy(
 
             if let Some(internal_keypair) = internal_keypair {
                 // ---------------------- Tr key spend --------------------
-                let internal_keypair = internal_keypair
-                    .tap_tweak(&secp, tr.spend_info().merkle_root());
+                let internal_keypair =
+                    internal_keypair.tap_tweak(&secp, tr.spend_info().merkle_root());
                 let sighash_msg = sighash_cache
                     .taproot_key_spend_signature_hash(0, &prevouts, sighash_type)
                     .unwrap();
                 let msg = secp256k1::Message::from_digest(sighash_msg.to_byte_array());
                 let mut aux_rand = [0u8; 32];
                 rand::thread_rng().fill_bytes(&mut aux_rand);
-                let schnorr_sig =
-                    secp.sign_schnorr_with_aux_rand(&msg, &internal_keypair.to_keypair(), &aux_rand);
+                let schnorr_sig = secp.sign_schnorr_with_aux_rand(
+                    &msg,
+                    &internal_keypair.to_keypair(),
+                    &aux_rand,
+                );
                 psbt.inputs[0].tap_key_sig =
                     Some(taproot::Signature { signature: schnorr_sig, sighash_type });
             } else {
@@ -187,7 +191,8 @@ pub fn test_desc_satisfy(
             let x_only_keypairs_reqd: Vec<(secp256k1::Keypair, TapLeafHash)> = tr
                 .leaves()
                 .flat_map(|leaf| {
-                    let leaf_hash = TapLeafHash::from_script(&leaf.compute_script(), LeafVersion::TapScript);
+                    let leaf_hash =
+                        TapLeafHash::from_script(&leaf.compute_script(), LeafVersion::TapScript);
                     leaf.miniscript().iter_pk().filter_map(move |pk| {
                         let i = x_only_pks.iter().position(|&x| x.to_public_key() == pk);
                         i.map(|idx| (xonly_keypairs[idx], leaf_hash))
@@ -419,3 +424,160 @@ fn test_satisfy() {
     let cl = &setup::setup().client;
     test_descs(cl, &testdata);
 }
+
+/// Test that Plan::satisfy() correctly constructs witness for P2WSH descriptors.
+/// This is a regression test for https://github.com/rust-bitcoin/rust-miniscript/issues/896
+pub fn test_plan_satisfy_wsh(
+    cl: &Client,
+    testdata: &TestData,
+    descriptor: &str,
+) -> Result<Witness, DescError> {
+    use std::collections::BTreeMap;
+
+    use miniscript::plan::Assets;
+    use miniscript::DefiniteDescriptorKey;
+
+    let secp = secp256k1::Secp256k1::new();
+    let sks = &testdata.secretdata.sks;
+    let pks = &testdata.pubdata.pks;
+
+    // Generate some blocks
+    let blocks = cl
+        .generate_to_address(1, &cl.new_address().unwrap())
+        .unwrap();
+    assert_eq!(blocks.0.len(), 1);
+
+    let definite_desc = test_util::parse_test_desc(descriptor, &testdata.pubdata)
+        .map_err(|_| DescError::DescParseError)?
+        .at_derivation_index(0)
+        .unwrap();
+
+    let derived_desc = definite_desc.derived_descriptor(&secp);
+    let desc_address = derived_desc
+        .address(bitcoin::Network::Regtest)
+        .map_err(|_| DescError::AddressComputationError)?;
+
+    // Send some btc to the descriptor address
+    let txid = cl
+        .send_to_address(&desc_address, btc(1))
+        .expect("rpc call failed")
+        .txid()
+        .expect("conversion to model failed");
+
+    // Wait for the funds to mature
+    let blocks = cl
+        .generate_to_address(2, &cl.new_address().unwrap())
+        .unwrap();
+    assert_eq!(blocks.0.len(), 2);
+
+    // Get the UTXO
+    let (outpoint, witness_utxo) = get_vout(cl, txid, btc(1.0), derived_desc.script_pubkey());
+
+    // Build assets from known keys
+    let mut assets = Assets::new();
+    for pk in pks.iter() {
+        let dpk = miniscript::DescriptorPublicKey::Single(miniscript::descriptor::SinglePub {
+            origin: None,
+            key: miniscript::descriptor::SinglePubKey::FullKey(*pk),
+        });
+        assets = assets.add(dpk);
+    }
+
+    // Get a plan (clone since plan() takes ownership)
+    let plan = definite_desc
+        .clone()
+        .plan(&assets)
+        .expect("Failed to create plan");
+
+    // Create the sighash for signing
+    let mut unsigned_tx = Transaction {
+        version: transaction::Version::TWO,
+        lock_time: absolute::LockTime::from_time(1_603_866_330).expect("valid timestamp"),
+        input: vec![TxIn {
+            previous_output: outpoint,
+            sequence: Sequence::from_height(1),
+            ..Default::default()
+        }],
+        output: vec![TxOut {
+            value: Amount::from_sat(99_997_000),
+            script_pubkey: cl
+                .new_address_with_type(AddressType::Bech32)
+                .unwrap()
+                .script_pubkey(),
+        }],
+    };
+
+    let mut sighash_cache = SighashCache::new(&unsigned_tx);
+
+    // Compute the sighash based on descriptor type
+    use miniscript::descriptor::DescriptorType;
+    let sighash_type = sighash::EcdsaSighashType::All;
+    let desc_type = derived_desc.desc_type();
+    let sighash_msg = match desc_type {
+        DescriptorType::Wsh
+        | DescriptorType::WshSortedMulti
+        | DescriptorType::ShWsh
+        | DescriptorType::ShWshSortedMulti => {
+            let script_code = derived_desc.script_code().expect("has script_code");
+            sighash_cache
+                .p2wsh_signature_hash(0, &script_code, witness_utxo.value, sighash_type)
+                .expect("sighash")
+        }
+        _ => panic!("This test is only for WSH descriptors, got {:?}", desc_type),
+    };
+
+    let msg = secp256k1::Message::from_digest(sighash_msg.to_byte_array());
+
+    // Sign with all required keys and build a satisfier map
+    let mut sig_map: BTreeMap<DefiniteDescriptorKey, ecdsa::Signature> = BTreeMap::new();
+    for (i, pk) in pks.iter().enumerate() {
+        let signature = secp.sign_ecdsa(&msg, &sks[i]);
+        let dpk = DefiniteDescriptorKey::from_str(&pk.to_string()).unwrap();
+        sig_map.insert(dpk, ecdsa::Signature { signature, sighash_type });
+    }
+
+    // Use Plan::satisfy() to construct witness and script_sig
+    let (witness_stack, script_sig) = plan
+        .satisfy(&sig_map)
+        .expect("Plan::satisfy() should succeed");
+
+    // Set the witness and script_sig on the transaction
+    unsigned_tx.input[0].witness = Witness::from_slice(&witness_stack);
+    unsigned_tx.input[0].script_sig = script_sig;
+
+    // Broadcast the transaction
+    let txid = cl
+        .send_raw_transaction(&unsigned_tx)
+        .unwrap_or_else(|e| panic!("send tx failed for desc {}: {:?}", definite_desc, e))
+        .txid()
+        .expect("conversion to model failed");
+
+    // Mine a block and verify confirmation
+    let _blocks = cl
+        .generate_to_address(1, &cl.new_address().unwrap())
+        .unwrap();
+    let num_conf = cl.get_transaction(txid).unwrap().confirmations;
+    assert!(num_conf > 0);
+
+    Ok(unsigned_tx.input[0].witness.clone())
+}
+
+#[test]
+fn test_plan_satisfy() {
+    let testdata = TestData::new_fixed_data(50);
+    let cl = &setup::setup().client;
+
+    // Test native P2WSH with Plan::satisfy()
+    println!("Testing wsh(pk(K)) with Plan::satisfy()");
+    test_plan_satisfy_wsh(cl, &testdata, "wsh(pk(K))").unwrap();
+
+    println!("Testing wsh(multi(2,K1,K2,K3)) with Plan::satisfy()");
+    test_plan_satisfy_wsh(cl, &testdata, "wsh(multi(2,K1,K2,K3))").unwrap();
+
+    // Test P2SH-wrapped P2WSH with Plan::satisfy()
+    println!("Testing sh(wsh(pk(K))) with Plan::satisfy()");
+    test_plan_satisfy_wsh(cl, &testdata, "sh(wsh(pk(K)))").unwrap();
+
+    println!("Testing sh(wsh(multi(2,K1,K2,K3))) with Plan::satisfy()");
+    test_plan_satisfy_wsh(cl, &testdata, "sh(wsh(multi(2,K1,K2,K3)))").unwrap();
+}