Refactor: separate blockchain from lib.rs

bdk-ffi/src/blockchain.rs

@@ -0,0 +1,195 @@
+// use crate::BlockchainConfig;
+use crate::PartiallySignedTransaction;
+use bdk::bitcoin::Network;
+use bdk::blockchain::any::{AnyBlockchain, AnyBlockchainConfig};
+use bdk::blockchain::rpc::Auth as BdkAuth;
+use bdk::blockchain::rpc::RpcSyncParams as BdkRpcSyncParams;
+use bdk::blockchain::Blockchain as BdkBlockchain;
+use bdk::blockchain::GetBlockHash;
+use bdk::blockchain::GetHeight;
+use bdk::blockchain::{
+    electrum::ElectrumBlockchainConfig, esplora::EsploraBlockchainConfig,
+    rpc::RpcConfig as BdkRpcConfig, ConfigurableBlockchain,
+};
+use bdk::Error as BdkError;
+use std::convert::{From, TryFrom};
+use std::path::PathBuf;
+use std::sync::{Mutex, MutexGuard};
+
+pub(crate) struct Blockchain {
+    blockchain_mutex: Mutex<AnyBlockchain>,
+}
+
+impl Blockchain {
+    pub(crate) fn new(blockchain_config: BlockchainConfig) -> Result<Self, BdkError> {
+        let any_blockchain_config = match blockchain_config {
+            BlockchainConfig::Electrum { config } => {
+                AnyBlockchainConfig::Electrum(ElectrumBlockchainConfig {
+                    retry: config.retry,
+                    socks5: config.socks5,
+                    timeout: config.timeout,
+                    url: config.url,
+                    stop_gap: usize::try_from(config.stop_gap).unwrap(),
+                    validate_domain: config.validate_domain,
+                })
+            }
+            BlockchainConfig::Esplora { config } => {
+                AnyBlockchainConfig::Esplora(EsploraBlockchainConfig {
+                    base_url: config.base_url,
+                    proxy: config.proxy,
+                    concurrency: config.concurrency,
+                    stop_gap: usize::try_from(config.stop_gap).unwrap(),
+                    timeout: config.timeout,
+                })
+            }
+            BlockchainConfig::Rpc { config } => AnyBlockchainConfig::Rpc(BdkRpcConfig {
+                url: config.url,
+                auth: config.auth.into(),
+                network: config.network,
+                wallet_name: config.wallet_name,
+                sync_params: config.sync_params.map(|p| p.into()),
+            }),
+        };
+        let blockchain = AnyBlockchain::from_config(&any_blockchain_config)?;
+        Ok(Self {
+            blockchain_mutex: Mutex::new(blockchain),
+        })
+    }
+
+    pub(crate) fn get_blockchain(&self) -> MutexGuard<AnyBlockchain> {
+        self.blockchain_mutex.lock().expect("blockchain")
+    }
+
+    pub(crate) fn broadcast(&self, psbt: &PartiallySignedTransaction) -> Result<(), BdkError> {
+        let tx = psbt.internal.lock().unwrap().clone().extract_tx();
+        self.get_blockchain().broadcast(&tx)
+    }
+
+    pub(crate) fn get_height(&self) -> Result<u32, BdkError> {
+        self.get_blockchain().get_height()
+    }
+
+    pub(crate) fn get_block_hash(&self, height: u32) -> Result<String, BdkError> {
+        self.get_blockchain()
+            .get_block_hash(u64::from(height))
+            .map(|hash| hash.to_string())
+    }
+}
+
+/// Configuration for an ElectrumBlockchain
+pub struct ElectrumConfig {
+    /// URL of the Electrum server (such as ElectrumX, Esplora, BWT) may start with ssl:// or tcp:// and include a port
+    /// e.g. ssl://electrum.blockstream.info:60002
+    pub url: String,
+    /// URL of the socks5 proxy server or a Tor service
+    pub socks5: Option<String>,
+    /// Request retry count
+    pub retry: u8,
+    /// Request timeout (seconds)
+    pub timeout: Option<u8>,
+    /// Stop searching addresses for transactions after finding an unused gap of this length
+    pub stop_gap: u64,
+    /// Validate the domain when using SSL
+    pub validate_domain: bool,
+}
+
+/// Configuration for an EsploraBlockchain
+pub struct EsploraConfig {
+    /// Base URL of the esplora service
+    /// e.g. https://blockstream.info/api/
+    pub base_url: String,
+    /// Optional URL of the proxy to use to make requests to the Esplora server
+    /// The string should be formatted as: <protocol>://<user>:<password>@host:<port>.
+    /// Note that the format of this value and the supported protocols change slightly between the
+    /// sync version of esplora (using ureq) and the async version (using reqwest). For more
+    /// details check with the documentation of the two crates. Both of them are compiled with
+    /// the socks feature enabled.
+    /// The proxy is ignored when targeting wasm32.
+    pub proxy: Option<String>,
+    /// Number of parallel requests sent to the esplora service (default: 4)
+    pub concurrency: Option<u8>,
+    /// Stop searching addresses for transactions after finding an unused gap of this length.
+    pub stop_gap: u64,
+    /// Socket timeout.
+    pub timeout: Option<u64>,
+}
+
+pub enum Auth {
+    /// No authentication
+    None,
+    /// Authentication with username and password, usually [Auth::Cookie] should be preferred
+    UserPass {
+        /// Username
+        username: String,
+        /// Password
+        password: String,
+    },
+    /// Authentication with a cookie file
+    Cookie {
+        /// Cookie file
+        file: String,
+    },
+}
+
+impl From<Auth> for BdkAuth {
+    fn from(auth: Auth) -> Self {
+        match auth {
+            Auth::None => BdkAuth::None,
+            Auth::UserPass { username, password } => BdkAuth::UserPass { username, password },
+            Auth::Cookie { file } => BdkAuth::Cookie {
+                file: PathBuf::from(file),
+            },
+        }
+    }
+}
+
+/// Sync parameters for Bitcoin Core RPC.
+///
+/// In general, BDK tries to sync `scriptPubKey`s cached in `Database` with
+/// `scriptPubKey`s imported in the Bitcoin Core Wallet. These parameters are used for determining
+/// how the `importdescriptors` RPC calls are to be made.
+pub struct RpcSyncParams {
+    /// The minimum number of scripts to scan for on initial sync.
+    pub start_script_count: u64,
+    /// Time in unix seconds in which initial sync will start scanning from (0 to start from genesis).
+    pub start_time: u64,
+    /// Forces every sync to use `start_time` as import timestamp.
+    pub force_start_time: bool,
+    /// RPC poll rate (in seconds) to get state updates.
+    pub poll_rate_sec: u64,
+}
+
+impl From<RpcSyncParams> for BdkRpcSyncParams {
+    fn from(params: RpcSyncParams) -> Self {
+        BdkRpcSyncParams {
+            start_script_count: params.start_script_count as usize,
+            start_time: params.start_time,
+            force_start_time: params.force_start_time,
+            poll_rate_sec: params.poll_rate_sec,
+        }
+    }
+}
+
+/// RpcBlockchain configuration options
+pub struct RpcConfig {
+    /// The bitcoin node url
+    pub url: String,
+    /// The bitcoin node authentication mechanism
+    pub auth: Auth,
+    /// The network we are using (it will be checked the bitcoin node network matches this)
+    pub network: Network,
+    /// The wallet name in the bitcoin node, consider using [crate::wallet::wallet_name_from_descriptor] for this
+    pub wallet_name: String,
+    /// Sync parameters
+    pub sync_params: Option<RpcSyncParams>,
+}
+
+/// Type that can contain any of the blockchain configurations defined by the library.
+pub enum BlockchainConfig {
+    /// Electrum client
+    Electrum { config: ElectrumConfig },
+    /// Esplora client
+    Esplora { config: EsploraConfig },
+    /// Bitcoin Core RPC client
+    Rpc { config: RpcConfig },
+}

bdk-ffi/src/lib.rs

@@ -1,21 +1,18 @@
+mod blockchain;
 mod psbt;
 mod wallet;
 
+use crate::blockchain::{
+    Auth, Blockchain, BlockchainConfig, ElectrumConfig, EsploraConfig, RpcConfig, RpcSyncParams,
+};
 use crate::psbt::PartiallySignedTransaction;
 use crate::wallet::{BumpFeeTxBuilder, TxBuilder, Wallet};
+
 use bdk::bitcoin::blockdata::script::Script as BdkScript;
 use bdk::bitcoin::secp256k1::Secp256k1;
 use bdk::bitcoin::util::bip32::{DerivationPath as BdkDerivationPath, Fingerprint};
 use bdk::bitcoin::{Address as BdkAddress, Network, OutPoint as BdkOutPoint, Txid};
-use bdk::blockchain::any::{AnyBlockchain, AnyBlockchainConfig};
+use bdk::blockchain::Progress as BdkProgress;
-use bdk::blockchain::rpc::Auth as BdkAuth;
-use bdk::blockchain::GetBlockHash;
-use bdk::blockchain::GetHeight;
-use bdk::blockchain::{
-    electrum::ElectrumBlockchainConfig, esplora::EsploraBlockchainConfig,
-    rpc::RpcConfig as BdkRpcConfig, rpc::RpcSyncParams as BdkRpcSyncParams, ConfigurableBlockchain,
-};
-use bdk::blockchain::{Blockchain as BdkBlockchain, Progress as BdkProgress};
 use bdk::database::any::{SledDbConfiguration, SqliteDbConfiguration};
 use bdk::descriptor::{DescriptorXKey, ExtendedDescriptor, IntoWalletDescriptor};
 use bdk::keys::bip39::{Language, Mnemonic as BdkMnemonic, WordCount};
@@ -31,12 +28,11 @@ use bdk::template::{
 use bdk::wallet::AddressIndex as BdkAddressIndex;
 use bdk::wallet::AddressInfo as BdkAddressInfo;
 use bdk::{Balance as BdkBalance, BlockTime, Error as BdkError, FeeRate, KeychainKind};
-use std::convert::{From, TryFrom};
+use std::convert::From;
 use std::fmt;
 use std::ops::Deref;
-use std::path::PathBuf;
 use std::str::FromStr;
-use std::sync::{Arc, Mutex, MutexGuard};
+use std::sync::{Arc, Mutex};
 
 uniffi_macros::include_scaffolding!("bdk");
 
@@ -99,124 +95,6 @@ pub enum DatabaseConfig {
     Sqlite { config: SqliteDbConfiguration },
 }
 
-/// Configuration for an ElectrumBlockchain
-pub struct ElectrumConfig {
-    /// URL of the Electrum server (such as ElectrumX, Esplora, BWT) may start with ssl:// or tcp:// and include a port
-    /// e.g. ssl://electrum.blockstream.info:60002
-    pub url: String,
-    /// URL of the socks5 proxy server or a Tor service
-    pub socks5: Option<String>,
-    /// Request retry count
-    pub retry: u8,
-    /// Request timeout (seconds)
-    pub timeout: Option<u8>,
-    /// Stop searching addresses for transactions after finding an unused gap of this length
-    pub stop_gap: u64,
-    /// Validate the domain when using SSL
-    pub validate_domain: bool,
-}
-
-/// Configuration for an EsploraBlockchain
-pub struct EsploraConfig {
-    /// Base URL of the esplora service
-    /// e.g. https://blockstream.info/api/
-    pub base_url: String,
-    /// Optional URL of the proxy to use to make requests to the Esplora server
-    /// The string should be formatted as: <protocol>://<user>:<password>@host:<port>.
-    /// Note that the format of this value and the supported protocols change slightly between the
-    /// sync version of esplora (using ureq) and the async version (using reqwest). For more
-    /// details check with the documentation of the two crates. Both of them are compiled with
-    /// the socks feature enabled.
-    /// The proxy is ignored when targeting wasm32.
-    pub proxy: Option<String>,
-    /// Number of parallel requests sent to the esplora service (default: 4)
-    pub concurrency: Option<u8>,
-    /// Stop searching addresses for transactions after finding an unused gap of this length.
-    pub stop_gap: u64,
-    /// Socket timeout.
-    pub timeout: Option<u64>,
-}
-
-pub enum Auth {
-    /// No authentication
-    None,
-    /// Authentication with username and password, usually [Auth::Cookie] should be preferred
-    UserPass {
-        /// Username
-        username: String,
-        /// Password
-        password: String,
-    },
-    /// Authentication with a cookie file
-    Cookie {
-        /// Cookie file
-        file: String,
-    },
-}
-
-impl From<Auth> for BdkAuth {
-    fn from(auth: Auth) -> Self {
-        match auth {
-            Auth::None => BdkAuth::None,
-            Auth::UserPass { username, password } => BdkAuth::UserPass { username, password },
-            Auth::Cookie { file } => BdkAuth::Cookie {
-                file: PathBuf::from(file),
-            },
-        }
-    }
-}
-
-/// Sync parameters for Bitcoin Core RPC.
-///
-/// In general, BDK tries to sync `scriptPubKey`s cached in `Database` with
-/// `scriptPubKey`s imported in the Bitcoin Core Wallet. These parameters are used for determining
-/// how the `importdescriptors` RPC calls are to be made.
-pub struct RpcSyncParams {
-    /// The minimum number of scripts to scan for on initial sync.
-    pub start_script_count: u64,
-    /// Time in unix seconds in which initial sync will start scanning from (0 to start from genesis).
-    pub start_time: u64,
-    /// Forces every sync to use `start_time` as import timestamp.
-    pub force_start_time: bool,
-    /// RPC poll rate (in seconds) to get state updates.
-    pub poll_rate_sec: u64,
-}
-
-impl From<RpcSyncParams> for BdkRpcSyncParams {
-    fn from(params: RpcSyncParams) -> Self {
-        BdkRpcSyncParams {
-            start_script_count: params.start_script_count as usize,
-            start_time: params.start_time,
-            force_start_time: params.force_start_time,
-            poll_rate_sec: params.poll_rate_sec,
-        }
-    }
-}
-
-/// RpcBlockchain configuration options
-pub struct RpcConfig {
-    /// The bitcoin node url
-    pub url: String,
-    /// The bitcoin node authentication mechanism
-    pub auth: Auth,
-    /// The network we are using (it will be checked the bitcoin node network matches this)
-    pub network: Network,
-    /// The wallet name in the bitcoin node, consider using [crate::wallet::wallet_name_from_descriptor] for this
-    pub wallet_name: String,
-    /// Sync parameters
-    pub sync_params: Option<RpcSyncParams>,
-}
-
-/// Type that can contain any of the blockchain configurations defined by the library.
-pub enum BlockchainConfig {
-    /// Electrum client
-    Electrum { config: ElectrumConfig },
-    /// Esplora client
-    Esplora { config: EsploraConfig },
-    /// Bitcoin Core RPC client
-    Rpc { config: RpcConfig },
-}
-
 /// A wallet transaction
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct TransactionDetails {
@@ -250,71 +128,71 @@ impl From<&bdk::TransactionDetails> for TransactionDetails {
     }
 }
 
-struct Blockchain {
+// struct Blockchain {
-    blockchain_mutex: Mutex<AnyBlockchain>,
+//     blockchain_mutex: Mutex<AnyBlockchain>,
-}
+// }
-
+//
-impl Blockchain {
+// impl Blockchain {
-    fn new(blockchain_config: BlockchainConfig) -> Result<Self, BdkError> {
+//     fn new(blockchain_config: BlockchainConfig) -> Result<Self, BdkError> {
-        let any_blockchain_config = match blockchain_config {
+//         let any_blockchain_config = match blockchain_config {
-            BlockchainConfig::Electrum { config } => {
+//             BlockchainConfig::Electrum { config } => {
-                AnyBlockchainConfig::Electrum(ElectrumBlockchainConfig {
+//                 AnyBlockchainConfig::Electrum(ElectrumBlockchainConfig {
-                    retry: config.retry,
+//                     retry: config.retry,
-                    socks5: config.socks5,
+//                     socks5: config.socks5,
-                    timeout: config.timeout,
+//                     timeout: config.timeout,
-                    url: config.url,
+//                     url: config.url,
-                    stop_gap: usize::try_from(config.stop_gap).unwrap(),
+//                     stop_gap: usize::try_from(config.stop_gap).unwrap(),
-                    validate_domain: config.validate_domain,
+//                     validate_domain: config.validate_domain,
-                })
+//                 })
-            }
+//             }
-            BlockchainConfig::Esplora { config } => {
+//             BlockchainConfig::Esplora { config } => {
-                AnyBlockchainConfig::Esplora(EsploraBlockchainConfig {
+//                 AnyBlockchainConfig::Esplora(EsploraBlockchainConfig {
-                    base_url: config.base_url,
+//                     base_url: config.base_url,
-                    proxy: config.proxy,
+//                     proxy: config.proxy,
-                    concurrency: config.concurrency,
+//                     concurrency: config.concurrency,
-                    stop_gap: usize::try_from(config.stop_gap).unwrap(),
+//                     stop_gap: usize::try_from(config.stop_gap).unwrap(),
-                    timeout: config.timeout,
+//                     timeout: config.timeout,
-                })
+//                 })
-            }
+//             }
-            BlockchainConfig::Rpc { config } => AnyBlockchainConfig::Rpc(BdkRpcConfig {
+//             BlockchainConfig::Rpc { config } => AnyBlockchainConfig::Rpc(BdkRpcConfig {
-                url: config.url,
+//                 url: config.url,
-                auth: config.auth.into(),
+//                 auth: config.auth.into(),
-                network: config.network,
+//                 network: config.network,
-                wallet_name: config.wallet_name,
+//                 wallet_name: config.wallet_name,
-                sync_params: config.sync_params.map(|p| p.into()),
+//                 sync_params: config.sync_params.map(|p| p.into()),
-            }),
+//             }),
-        };
+//         };
-        let blockchain = AnyBlockchain::from_config(&any_blockchain_config)?;
+//         let blockchain = AnyBlockchain::from_config(&any_blockchain_config)?;
-        Ok(Self {
+//         Ok(Self {
-            blockchain_mutex: Mutex::new(blockchain),
+//             blockchain_mutex: Mutex::new(blockchain),
-        })
+//         })
-    }
+//     }
-
+//
-    fn get_blockchain(&self) -> MutexGuard<AnyBlockchain> {
+//     fn get_blockchain(&self) -> MutexGuard<AnyBlockchain> {
-        self.blockchain_mutex.lock().expect("blockchain")
+//         self.blockchain_mutex.lock().expect("blockchain")
-    }
+//     }
-
+//
-    fn broadcast(&self, psbt: &PartiallySignedTransaction) -> Result<(), BdkError> {
+//     fn broadcast(&self, psbt: &PartiallySignedTransaction) -> Result<(), BdkError> {
-        let tx = psbt.internal.lock().unwrap().clone().extract_tx();
+//         let tx = psbt.internal.lock().unwrap().clone().extract_tx();
-        self.get_blockchain().broadcast(&tx)
+//         self.get_blockchain().broadcast(&tx)
-    }
+//     }
-
+//
-    fn estimate_fee(&self, target: u64) -> Result<Arc<FeeRate>, BdkError> {
+//     fn estimate_fee(&self, target: u64) -> Result<Arc<FeeRate>, BdkError> {
-        let result: Result<FeeRate, bdk::Error> =
+//         let result: Result<FeeRate, bdk::Error> =
-            self.get_blockchain().estimate_fee(target as usize);
+//             self.get_blockchain().estimate_fee(target as usize);
-        result.map(Arc::new)
+//         result.map(Arc::new)
-    }
+//     }
-
+//
-    fn get_height(&self) -> Result<u32, BdkError> {
+//     fn get_height(&self) -> Result<u32, BdkError> {
-        self.get_blockchain().get_height()
+//         self.get_blockchain().get_height()
-    }
+//     }
-
+//
-    fn get_block_hash(&self, height: u32) -> Result<String, BdkError> {
+//     fn get_block_hash(&self, height: u32) -> Result<String, BdkError> {
-        self.get_blockchain()
+//         self.get_blockchain()
-            .get_block_hash(u64::from(height))
+//             .get_block_hash(u64::from(height))
-            .map(|hash| hash.to_string())
+//             .map(|hash| hash.to_string())
-    }
+//     }
-}
+// }
 
 /// A reference to a transaction output.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

bdk-ffi/src/wallet.rs

@@ -11,11 +11,12 @@ use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::{Arc, Mutex, MutexGuard};
 
+use crate::blockchain::Blockchain;
 use crate::psbt::PartiallySignedTransaction;
 use crate::{
-    AddressIndex, AddressInfo, Balance, Blockchain, DatabaseConfig, Descriptor, LocalUtxo,
+    AddressIndex, AddressInfo, Balance, DatabaseConfig, Descriptor, LocalUtxo, NetworkLocalUtxo,
-    NetworkLocalUtxo, OutPoint, Progress, ProgressHolder, RbfValue, Script, ScriptAmount,
+    OutPoint, Progress, ProgressHolder, RbfValue, Script, ScriptAmount, TransactionDetails,
-    TransactionDetails, TxBuilderResult,
+    TxBuilderResult,
 };
 
 #[derive(Debug)]