Make corepc-node optional in payjoin-test-utils

Test constants (ORIGINAL_PSBT, EXAMPLE_URL, etc.) and the
TestServices infrastructure don't require bitcoind. Only
init_bitcoind* functions need the corepc-node crate, which
downloads a ~40MB binary at build time.

Move bitcoind-dependent functions to a `bitcoind` module,
gated behind a `bitcoind` feature (default = on). Re-export
from crate root for backwards compatibility. Downstream
consumers can now import payjoin-test-utils for constants
without triggering the bitcoind download.

Author: DanGould

payjoin-test-utils/Cargo.toml

@@ -8,10 +8,14 @@ repository = "https://github.com/payjoin/rust-payjoin"
 rust-version = "1.85"
 license = "MIT"
 
+[features]
+default = ["bitcoind"]
+bitcoind = ["dep:corepc-node"]
+
 [dependencies]
 axum-server = { version = "0.8", features = ["tls-rustls-no-provider"] }
 bitcoin = { version = "0.32.7", features = ["base64"] }
-corepc-node = { version = "0.10.0", features = ["download", "29_0"] }
+corepc-node = { version = "0.10.0", features = ["download", "29_0"], optional = true }
 http = "1.3.1"
 ohttp = { package = "bitcoin-ohttp", version = "0.6.0" }
 once_cell = "1.21.3"

payjoin-test-utils/src/bitcoind.rs

@@ -0,0 +1,73 @@
+use bitcoin::Amount;
+pub use corepc_node;
+use corepc_node::AddressType;
+use tracing::Level;
+
+use crate::BoxError;
+
+pub fn init_bitcoind() -> Result<corepc_node::Node, BoxError> {
+    let bitcoind_exe = corepc_node::exe_path()?;
+    let mut conf = corepc_node::Conf::default();
+    conf.view_stdout = tracing::enabled!(target: "corepc", Level::TRACE);
+    // conf.args.push("-txindex");
+    let bitcoind = corepc_node::Node::with_conf(bitcoind_exe, &conf)?;
+    Ok(bitcoind)
+}
+
+pub fn init_bitcoind_sender_receiver(
+    sender_address_type: Option<AddressType>,
+    receiver_address_type: Option<AddressType>,
+) -> Result<(corepc_node::Node, corepc_node::Client, corepc_node::Client), BoxError> {
+    let bitcoind = init_bitcoind()?;
+    let mut wallets = create_and_fund_wallets(
+        &bitcoind,
+        vec![("receiver", receiver_address_type), ("sender", sender_address_type)],
+    )?;
+    let receiver = wallets.pop().expect("receiver to exist");
+    let sender = wallets.pop().expect("sender to exist");
+
+    Ok((bitcoind, receiver, sender))
+}
+
+fn create_and_fund_wallets<W: AsRef<str>>(
+    bitcoind: &corepc_node::Node,
+    wallets: Vec<(W, Option<AddressType>)>,
+) -> Result<Vec<corepc_node::Client>, BoxError> {
+    let mut funded_wallets = vec![];
+    let funding_wallet = bitcoind.create_wallet("funding_wallet")?;
+    let funding_address = funding_wallet.new_address()?;
+    // 100 blocks would work here, we add a extra block to cover fees between transfers
+    bitcoind.client.generate_to_address(101 + wallets.len(), &funding_address)?;
+    for (wallet_name, address_type) in wallets {
+        let wallet = bitcoind.create_wallet(wallet_name)?;
+        let address = wallet.get_new_address(None, address_type)?.into_model()?.0.assume_checked();
+        funding_wallet.send_to_address(&address, Amount::from_btc(50.0)?)?;
+        funded_wallets.push(wallet);
+    }
+    // Mine the block which funds the different wallets
+    bitcoind.client.generate_to_address(1, &funding_address)?;
+
+    for wallet in funded_wallets.iter() {
+        let balances = wallet.get_balances()?.into_model()?;
+        assert_eq!(
+            balances.mine.trusted,
+            Amount::from_btc(50.0)?,
+            "wallet doesn't have expected amount of bitcoin"
+        );
+    }
+
+    Ok(funded_wallets)
+}
+
+pub fn init_bitcoind_multi_sender_single_reciever(
+    number_of_senders: usize,
+) -> Result<(corepc_node::Node, Vec<corepc_node::Client>, corepc_node::Client), BoxError> {
+    let bitcoind = init_bitcoind()?;
+    let wallets_to_create =
+        (0..number_of_senders + 1).map(|i| (format!("sender_{i}"), None)).collect::<Vec<_>>();
+    let mut wallets = create_and_fund_wallets(&bitcoind, wallets_to_create)?;
+    let receiver = wallets.pop().expect("receiver to exist");
+    let senders = wallets;
+
+    Ok((bitcoind, senders, receiver))
+}

payjoin-test-utils/src/lib.rs

@@ -3,10 +3,13 @@ use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
 
+#[cfg(feature = "bitcoind")]
+pub mod bitcoind;
+#[cfg(feature = "bitcoind")]
+pub use bitcoind::*;
+
 use axum_server::tls_rustls::RustlsConfig;
-use bitcoin::{Amount, Psbt};
-pub use corepc_node; // re-export for convenience
-use corepc_node::AddressType;
+use bitcoin::Psbt;
 use http::StatusCode;
 use ohttp::hpke::{Aead, Kdf, Kem};
 use ohttp::{KeyId, SymmetricSuite};
@@ -19,7 +22,6 @@ use rustls::pki_types::CertificateDer;
 use rustls::RootCertStore;
 use tempfile::tempdir;
 use tokio::task::JoinHandle;
-use tracing::Level;
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
 pub type BoxError = Box<dyn std::error::Error + 'static>;
@@ -173,77 +175,10 @@ pub fn local_cert_key() -> rcgen::CertifiedKey<rcgen::KeyPair> {
         .expect("Failed to generate cert")
 }
 
-pub fn init_bitcoind() -> Result<corepc_node::Node, BoxError> {
-    let bitcoind_exe = corepc_node::exe_path()?;
-    let mut conf = corepc_node::Conf::default();
-    conf.view_stdout = tracing::enabled!(target: "corepc", Level::TRACE);
-    // conf.args.push("-txindex");
-    let bitcoind = corepc_node::Node::with_conf(bitcoind_exe, &conf)?;
-    Ok(bitcoind)
-}
-
-pub fn init_bitcoind_sender_receiver(
-    sender_address_type: Option<AddressType>,
-    receiver_address_type: Option<AddressType>,
-) -> Result<(corepc_node::Node, corepc_node::Client, corepc_node::Client), BoxError> {
-    let bitcoind = init_bitcoind()?;
-    let mut wallets = create_and_fund_wallets(
-        &bitcoind,
-        vec![("receiver", receiver_address_type), ("sender", sender_address_type)],
-    )?;
-    let receiver = wallets.pop().expect("receiver to exist");
-    let sender = wallets.pop().expect("sender to exist");
-
-    Ok((bitcoind, receiver, sender))
-}
-
-fn create_and_fund_wallets<W: AsRef<str>>(
-    bitcoind: &corepc_node::Node,
-    wallets: Vec<(W, Option<AddressType>)>,
-) -> Result<Vec<corepc_node::Client>, BoxError> {
-    let mut funded_wallets = vec![];
-    let funding_wallet = bitcoind.create_wallet("funding_wallet")?;
-    let funding_address = funding_wallet.new_address()?;
-    // 100 blocks would work here, we add a extra block to cover fees between transfers
-    bitcoind.client.generate_to_address(101 + wallets.len(), &funding_address)?;
-    for (wallet_name, address_type) in wallets {
-        let wallet = bitcoind.create_wallet(wallet_name)?;
-        let address = wallet.get_new_address(None, address_type)?.into_model()?.0.assume_checked();
-        funding_wallet.send_to_address(&address, Amount::from_btc(50.0)?)?;
-        funded_wallets.push(wallet);
-    }
-    // Mine the block which funds the different wallets
-    bitcoind.client.generate_to_address(1, &funding_address)?;
-
-    for wallet in funded_wallets.iter() {
-        let balances = wallet.get_balances()?.into_model()?;
-        assert_eq!(
-            balances.mine.trusted,
-            Amount::from_btc(50.0)?,
-            "wallet doesn't have expected amount of bitcoin"
-        );
-    }
-
-    Ok(funded_wallets)
-}
-
 pub fn http_agent(cert_der: Vec<u8>) -> Result<Client, BoxSendSyncError> {
     Ok(http_agent_builder(cert_der).build()?)
 }
 
-pub fn init_bitcoind_multi_sender_single_reciever(
-    number_of_senders: usize,
-) -> Result<(corepc_node::Node, Vec<corepc_node::Client>, corepc_node::Client), BoxError> {
-    let bitcoind = init_bitcoind()?;
-    let wallets_to_create =
-        (0..number_of_senders + 1).map(|i| (format!("sender_{i}"), None)).collect::<Vec<_>>();
-    let mut wallets = create_and_fund_wallets(&bitcoind, wallets_to_create)?;
-    let receiver = wallets.pop().expect("receiver to exist");
-    let senders = wallets;
-
-    Ok((bitcoind, senders, receiver))
-}
-
 fn http_agent_builder(cert_der: Vec<u8>) -> ClientBuilder {
     ClientBuilder::new().http1_only().use_rustls_tls().add_root_certificate(
         reqwest::tls::Certificate::from_der(cert_der.as_slice())