test: delete bitcoind tests

Sigh, after all the work I did to get a lockfile for the previous commit,
it turns out that all the bitcoind tests were disabled anyway, with the
explanation "breaking change in bitcoind".

This commit deletes them entirely. We have no plans to fix them. If we
ever want to regression test miniscript 9.x, we should do it externally
by adding a fuzztest in master which pulls it in and tries to parse
stuff. Then it will be actively exercised and maintained and not require
ancient broken dependencies.

This commit is all red EXCEPT a change to a test in src/miniscript/mod.rs.
What's happening here is that we had one test (asserting on the string
representation of errors from rust-bitcoin) which fails when the std
feature is off. As it turns out, `bitcoind` unconditionally turns on that
feature. So by having `bitcoind` as a dev-dependency it was impossible
for us to ever test the nostd feature properly. Sigh.

Author: apoelstra

Cargo-recent.lock

@@ -29,7 +29,6 @@ hashbrown = { version = "0.11", optional = true }
 actual-serde = { package = "serde", version = "1.0", optional = true }
 
 [dev-dependencies]
-bitcoind = { version = "0.27.0", features=["23_0"] }
 actual-rand = { package = "rand", version = "0.8.4"}
 secp256k1 = {version = "0.24.0", features = ["rand-std"]}
 

Cargo.toml

@@ -4,8 +4,7 @@ use std::str::FromStr;
 use bitcoin::consensus::serialize;
 use bitcoin::util::sighash::SighashCache;
 use bitcoin::{PackedLockTime, PrivateKey};
-use bitcoind::bitcoincore_rpc::jsonrpc::base64;
-use bitcoind::bitcoincore_rpc::RawTx;
+use bitcoin::hashes::hex::ToHex as _;
 use miniscript::bitcoin::consensus::encode::deserialize;
 use miniscript::bitcoin::hashes::hex::FromHex;
 use miniscript::bitcoin::util::psbt;
@@ -158,14 +157,18 @@ fn main() {
 
     println!("{:#?}", psbt);
 
+    /*
+    // In bitcoin 0.29.x there is no base64 encoding of PSBTs, so this line
+    // would require an entire extra dependency.
     let serialized = serialize(&psbt);
     println!("{}", base64::encode(&serialized));
+    */
 
     psbt.finalize_mut(&secp256k1).unwrap();
     println!("{:#?}", psbt);
 
     let tx = psbt.extract_tx();
-    println!("{}", tx.raw_hex());
+    println!("{}", serialize(&tx).to_hex());
 }
 
 // Find the Outpoint by spk

examples/psbt_sign_finalize.rs

@@ -996,8 +996,8 @@ mod tests {
             "pk(2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
         ));
         assert_eq!(
-            ms.unwrap_err().to_string(),
-            "unexpected «key hex decoding error»",
+            &ms.unwrap_err().to_string()[..35],
+            "unexpected «key hex decoding error",
         );
         Tapscript::from_str_insane(&format!(
             "pk(2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"

src/miniscript/mod.rs

@@ -1,24 +1,4 @@
 extern crate miniscript;
 
-use bitcoind::bitcoincore_rpc::RpcApi;
-use bitcoind::BitcoinD;
-use miniscript::bitcoin;
-
 pub mod test_util;
 
-// Launch an instance of bitcoind with
-pub fn setup() -> BitcoinD {
-    let exe_path = bitcoind::exe_path().unwrap();
-    let bitcoind = bitcoind::BitcoinD::new(exe_path).unwrap();
-    let cl = &bitcoind.client;
-    // generate to an address by the wallet. And wait for funds to mature
-    let addr = cl.get_new_address(None, None).unwrap();
-    let blks = cl.generate_to_address(101, &addr).unwrap();
-    assert_eq!(blks.len(), 101);
-
-    assert_eq!(
-        cl.get_balance(Some(1) /*min conf*/, None).unwrap(),
-        bitcoin::Amount::from_sat(100_000_000 * 50)
-    );
-    bitcoind
-}

tests/setup/mod.rs

@@ -22,7 +22,6 @@ use std::str::FromStr;
 use actual_rand as rand;
 use bitcoin::hashes::hex::ToHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
-use bitcoin::secp256k1;
 use miniscript::descriptor::{SinglePub, SinglePubKey};
 use miniscript::{
     hash256, Descriptor, DescriptorPublicKey, Error, Miniscript, ScriptContext, TranslatePk,
@@ -54,81 +53,6 @@ pub struct TestData {
     pub secretdata: SecretData,
 }
 
-// Setup (sk, pk) pairs
-fn setup_keys(
-    n: usize,
-) -> (
-    Vec<bitcoin::secp256k1::SecretKey>,
-    Vec<miniscript::bitcoin::PublicKey>,
-    Vec<bitcoin::KeyPair>,
-    Vec<bitcoin::XOnlyPublicKey>,
-) {
-    let secp_sign = secp256k1::Secp256k1::signing_only();
-    let mut sk = [0; 32];
-    let mut sks = vec![];
-    let mut pks = vec![];
-    for i in 1..n + 1 {
-        sk[0] = i as u8;
-        sk[1] = (i >> 8) as u8;
-        sk[2] = (i >> 16) as u8;
-
-        let sk = secp256k1::SecretKey::from_slice(&sk[..]).expect("secret key");
-        let pk = miniscript::bitcoin::PublicKey {
-            inner: secp256k1::PublicKey::from_secret_key(&secp_sign, &sk),
-            compressed: true,
-        };
-        pks.push(pk);
-        sks.push(sk);
-    }
-
-    let mut x_only_keypairs = vec![];
-    let mut x_only_pks = vec![];
-
-    for i in 0..n {
-        let keypair = bitcoin::KeyPair::from_secret_key(&secp_sign, &sks[i]);
-        let (xpk, _parity) = bitcoin::XOnlyPublicKey::from_keypair(&keypair);
-        x_only_keypairs.push(keypair);
-        x_only_pks.push(xpk);
-    }
-    (sks, pks, x_only_keypairs, x_only_pks)
-}
-
-impl TestData {
-    // generate a fixed data for n keys
-    pub(crate) fn new_fixed_data(n: usize) -> Self {
-        let (sks, pks, x_only_keypairs, x_only_pks) = setup_keys(n);
-        let sha256_pre = [0x12 as u8; 32];
-        let sha256 = sha256::Hash::hash(&sha256_pre);
-        let hash256_pre = [0x34 as u8; 32];
-        let hash256 = hash256::Hash::hash(&hash256_pre);
-        let hash160_pre = [0x56 as u8; 32];
-        let hash160 = hash160::Hash::hash(&hash160_pre);
-        let ripemd160_pre = [0x78 as u8; 32];
-        let ripemd160 = ripemd160::Hash::hash(&ripemd160_pre);
-
-        let pubdata = PubData {
-            pks,
-            sha256,
-            hash256,
-            ripemd160,
-            hash160,
-            x_only_pks,
-        };
-        let secretdata = SecretData {
-            sks,
-            sha256_pre,
-            hash256_pre,
-            ripemd160_pre,
-            hash160_pre,
-            x_only_keypairs,
-        };
-        Self {
-            pubdata,
-            secretdata,
-        }
-    }
-}
-
 /// Obtain an insecure random public key with unknown secret key for testing
 pub fn random_pk(mut seed: u8) -> bitcoin::PublicKey {
     loop {