From 2e43efda80820ce99b210a5eecd083a04679cfa6 Mon Sep 17 00:00:00 2001
From: Matthew <ramsden@hey.com>
Date: Sat, 14 Oct 2023 20:16:38 -0500
Subject: [PATCH] delete unused code except for tests

---
 Cargo.lock                |  10 +-
 bdk-ffi/src/bdk.udl       |   1 -
 bdk-ffi/src/blockchain.rs | 203 +-------------
 bdk-ffi/src/database.rs   |  15 +-
 bdk-ffi/src/descriptor.rs | 253 +----------------
 bdk-ffi/src/keys.rs       | 247 +----------------
 bdk-ffi/src/lib.rs        | 472 +------------------------------
 bdk-ffi/src/psbt.rs       |  79 ------
 bdk-ffi/src/wallet.rs     | 565 +-------------------------------------
 9 files changed, 18 insertions(+), 1827 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8821c9de..6fe214a8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -84,8 +84,9 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
 [[package]]
 name = "bdk"
-version = "1.0.0-alpha.1"
-source = "git+https://github.com/bitcoindevkit/bdk.git?rev=59fc1b341ba94212b2ea3e888e51fb6fcd00589f#59fc1b341ba94212b2ea3e888e51fb6fcd00589f"
+version = "1.0.0-alpha.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99559c90df27c7dac369182a47ec96425f71764540765bba6558ea79877e50ee"
 dependencies = [
  "bdk_chain",
  "bip39",
@@ -110,8 +111,9 @@ dependencies = [
 
 [[package]]
 name = "bdk_chain"
-version = "0.5.0"
-source = "git+https://github.com/bitcoindevkit/bdk.git?rev=59fc1b341ba94212b2ea3e888e51fb6fcd00589f#59fc1b341ba94212b2ea3e888e51fb6fcd00589f"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5043c1254d39534da6b2ca67e139aac8e9a4719671ae6b4063ecd2c791179879"
 dependencies = [
  "bitcoin",
  "miniscript",
diff --git a/bdk-ffi/src/bdk.udl b/bdk-ffi/src/bdk.udl
index cf2f3c97..921283fe 100644
--- a/bdk-ffi/src/bdk.udl
+++ b/bdk-ffi/src/bdk.udl
@@ -173,7 +173,6 @@ interface AddressIndex {
   Peek(u32 index);
 };
 
-
 interface Balance {
   u64 immature();
   u64 trusted_pending();
diff --git a/bdk-ffi/src/blockchain.rs b/bdk-ffi/src/blockchain.rs
index c65edeeb..8b137891 100644
--- a/bdk-ffi/src/blockchain.rs
+++ b/bdk-ffi/src/blockchain.rs
@@ -1,202 +1 @@
-// // use crate::BlockchainConfig;
-// use crate::{BdkError, Transaction};
-// use crate::BdkError;
-// 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::FeeRate;
-// use std::convert::{From, TryFrom};
-// use std::path::PathBuf;
-// use std::sync::{Arc, Mutex, MutexGuard};
-//
-// pub(crate) struct Blockchain {
-//     inner_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 {
-//             inner_mutex: Mutex::new(blockchain),
-//         })
-//     }
-//
-//     pub(crate) fn get_blockchain(&self) -> MutexGuard<AnyBlockchain> {
-//         self.inner_mutex.lock().expect("blockchain")
-//     }
-//
-//     pub(crate) fn broadcast(&self, transaction: &Transaction) -> Result<(), BdkError> {
-//         let tx = &transaction.inner;
-//         self.get_blockchain().broadcast(tx)
-//     }
-//
-//     pub(crate) fn estimate_fee(&self, target: u64) -> Result<Arc<FeeRate>, BdkError> {
-//         let result: Result<FeeRate, bdk::Error> =
-//             self.get_blockchain().estimate_fee(target as usize);
-//         result.map(Arc::new)
-//     }
-//
-//     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 },
-// }
+
diff --git a/bdk-ffi/src/database.rs b/bdk-ffi/src/database.rs
index 63cbfb59..8b137891 100644
--- a/bdk-ffi/src/database.rs
+++ b/bdk-ffi/src/database.rs
@@ -1,14 +1 @@
-// use bdk::database::any::{SledDbConfiguration, SqliteDbConfiguration};
-//
-// /// Type that can contain any of the database configurations defined by the library
-// /// This allows storing a single configuration that can be loaded into an AnyDatabaseConfig
-// /// instance. Wallets that plan to offer users the ability to switch blockchain backend at runtime
-// /// will find this particularly useful.
-// pub enum DatabaseConfig {
-//     /// Memory database has no config
-//     Memory,
-//     /// Simple key-value embedded database based on sled
-//     Sled { config: SledDbConfiguration },
-//     /// Sqlite embedded database using rusqlite
-//     Sqlite { config: SqliteDbConfiguration },
-// }
+
diff --git a/bdk-ffi/src/descriptor.rs b/bdk-ffi/src/descriptor.rs
index ee2d4217..61f75753 100644
--- a/bdk-ffi/src/descriptor.rs
+++ b/bdk-ffi/src/descriptor.rs
@@ -1,5 +1,8 @@
 // use crate::{BdkError, DescriptorPublicKey, DescriptorSecretKey};
+use crate::keys::DescriptorPublicKey;
+use crate::keys::DescriptorSecretKey;
 use crate::BdkError;
+use crate::Network;
 use bdk::bitcoin::bip32::Fingerprint;
 use bdk::bitcoin::key::Secp256k1;
 use bdk::descriptor::{ExtendedDescriptor, IntoWalletDescriptor};
@@ -13,10 +16,6 @@ use bdk::KeychainKind;
 use std::str::FromStr;
 use std::sync::Arc;
 
-use crate::keys::DescriptorPublicKey;
-use crate::keys::DescriptorSecretKey;
-use crate::Network;
-
 #[derive(Debug)]
 pub(crate) struct Descriptor {
     pub extended_descriptor: ExtendedDescriptor,
@@ -277,252 +276,6 @@ impl Descriptor {
     }
 }
 
-// use bdk::bitcoin::secp256k1::Secp256k1;
-// use bdk::bitcoin::util::bip32::Fingerprint;
-// use bdk::bitcoin::Network;
-// use bdk::descriptor::{ExtendedDescriptor, IntoWalletDescriptor, KeyMap};
-// use bdk::keys::{
-//     DescriptorPublicKey as BdkDescriptorPublicKey, DescriptorSecretKey as BdkDescriptorSecretKey,
-// };
-// use bdk::template::{
-//     Bip44, Bip44Public, Bip49, Bip49Public, Bip84, Bip84Public, Bip86, Bip86Public,
-//     DescriptorTemplate,
-// };
-// use bdk::KeychainKind;
-// use std::str::FromStr;
-// use std::sync::Arc;
-//
-// #[derive(Debug)]
-// pub(crate) struct Descriptor {
-//     pub(crate) extended_descriptor: ExtendedDescriptor,
-//     pub(crate) key_map: KeyMap,
-// }
-//
-// impl Descriptor {
-//     pub(crate) fn new(descriptor: String, network: Network) -> Result<Self, BdkError> {
-//         let secp = Secp256k1::new();
-//         let (extended_descriptor, key_map) = descriptor.into_wallet_descriptor(&secp, network)?;
-//         Ok(Self {
-//             extended_descriptor,
-//             key_map,
-//         })
-//     }
-//
-//     pub(crate) fn new_bip44(
-//         secret_key: Arc<DescriptorSecretKey>,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let derivable_key = &secret_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorSecretKey::XPrv(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip44(derivable_key, keychain_kind).build(network).unwrap();
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorSecretKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn new_bip44_public(
-//         public_key: Arc<DescriptorPublicKey>,
-//         fingerprint: String,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let fingerprint = Fingerprint::from_str(fingerprint.as_str()).unwrap();
-//         let derivable_key = &public_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorPublicKey::XPub(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip44Public(derivable_key, fingerprint, keychain_kind)
-//                         .build(network)
-//                         .unwrap();
-//
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorPublicKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn new_bip49(
-//         secret_key: Arc<DescriptorSecretKey>,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let derivable_key = &secret_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorSecretKey::XPrv(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip49(derivable_key, keychain_kind).build(network).unwrap();
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorSecretKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn new_bip49_public(
-//         public_key: Arc<DescriptorPublicKey>,
-//         fingerprint: String,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let fingerprint = Fingerprint::from_str(fingerprint.as_str()).unwrap();
-//         let derivable_key = &public_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorPublicKey::XPub(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip49Public(derivable_key, fingerprint, keychain_kind)
-//                         .build(network)
-//                         .unwrap();
-//
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorPublicKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn new_bip84(
-//         secret_key: Arc<DescriptorSecretKey>,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let derivable_key = &secret_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorSecretKey::XPrv(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip84(derivable_key, keychain_kind).build(network).unwrap();
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorSecretKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn new_bip84_public(
-//         public_key: Arc<DescriptorPublicKey>,
-//         fingerprint: String,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let fingerprint = Fingerprint::from_str(fingerprint.as_str()).unwrap();
-//         let derivable_key = &public_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorPublicKey::XPub(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip84Public(derivable_key, fingerprint, keychain_kind)
-//                         .build(network)
-//                         .unwrap();
-//
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorPublicKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn new_bip86(
-//         secret_key: Arc<DescriptorSecretKey>,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let derivable_key = &secret_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorSecretKey::XPrv(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip86(derivable_key, keychain_kind).build(network).unwrap();
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorSecretKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn new_bip86_public(
-//         public_key: Arc<DescriptorPublicKey>,
-//         fingerprint: String,
-//         keychain_kind: KeychainKind,
-//         network: Network,
-//     ) -> Self {
-//         let fingerprint = Fingerprint::from_str(fingerprint.as_str()).unwrap();
-//         let derivable_key = &public_key.inner;
-//
-//         match derivable_key {
-//             BdkDescriptorPublicKey::XPub(descriptor_x_key) => {
-//                 let derivable_key = descriptor_x_key.xkey;
-//                 let (extended_descriptor, key_map, _) =
-//                     Bip86Public(derivable_key, fingerprint, keychain_kind)
-//                         .build(network)
-//                         .unwrap();
-//
-//                 Self {
-//                     extended_descriptor,
-//                     key_map,
-//                 }
-//             }
-//             BdkDescriptorPublicKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         }
-//     }
-//
-//     pub(crate) fn as_string_private(&self) -> String {
-//         let descriptor = &self.extended_descriptor;
-//         let key_map = &self.key_map;
-//         descriptor.to_string_with_secret(key_map)
-//     }
-//
-//     pub(crate) fn as_string(&self) -> String {
-//         self.extended_descriptor.to_string()
-//     }
-// }
-//
 // // The goal of these tests to to ensure `bdk-ffi` intermediate code correctly calls `bdk` APIs.
 // // These tests should not be used to verify `bdk` behavior that is already tested in the `bdk`
 // // crate.
diff --git a/bdk-ffi/src/keys.rs b/bdk-ffi/src/keys.rs
index d6cec202..b491c3fc 100644
--- a/bdk-ffi/src/keys.rs
+++ b/bdk-ffi/src/keys.rs
@@ -1,5 +1,3 @@
-// use crate::BdkError;
-
 use bdk::bitcoin::bip32::DerivationPath as BdkDerivationPath;
 use bdk::Error as BdkError;
 use std::str::FromStr;
@@ -19,21 +17,18 @@ impl DerivationPath {
     }
 }
 
+use crate::Network;
 use bdk::bitcoin::key::Secp256k1;
 use bdk::bitcoin::secp256k1::rand;
 use bdk::bitcoin::secp256k1::rand::Rng;
-// use bdk::keys::{DescriptorSecretKey as BdkDescriptorSecretKey, GeneratableKey, GeneratedKey};
 use bdk::keys::bip39::WordCount;
 use bdk::keys::bip39::{Language, Mnemonic as BdkMnemonic};
 use bdk::keys::{
     DerivableKey, DescriptorPublicKey as BdkDescriptorPublicKey,
     DescriptorSecretKey as BdkDescriptorSecretKey, ExtendedKey, GeneratableKey, GeneratedKey,
 };
-use bdk::miniscript::BareCtx;
-
 use bdk::miniscript::descriptor::{DescriptorXKey, Wildcard};
-
-use crate::Network;
+use bdk::miniscript::BareCtx;
 
 pub(crate) struct Mnemonic {
     inner: BdkMnemonic,
@@ -263,247 +258,9 @@ impl DescriptorPublicKey {
     }
 }
 
-//
-// use bdk::bitcoin::secp256k1::Secp256k1;
-// use bdk::bitcoin::util::bip32::DerivationPath as BdkDerivationPath;
-// use bdk::bitcoin::Network;
-// use bdk::descriptor::DescriptorXKey;
-// use bdk::keys::bip39::{Language, Mnemonic as BdkMnemonic, WordCount};
-// use bdk::keys::{
-//     DerivableKey, DescriptorPublicKey as BdkDescriptorPublicKey,
-//     DescriptorSecretKey as BdkDescriptorSecretKey, ExtendedKey, GeneratableKey, GeneratedKey,
-// };
-// use bdk::miniscript::BareCtx;
 use std::ops::Deref;
 use std::sync::Arc;
 
-// use std::str::FromStr;
-// use std::sync::{Arc, Mutex};
-//
-// /// Mnemonic phrases are a human-readable version of the private keys.
-// /// Supported number of words are 12, 15, 18, 21 and 24.
-// pub(crate) struct Mnemonic {
-//     inner: BdkMnemonic,
-// }
-//
-// impl Mnemonic {
-//     /// Generates Mnemonic with a random entropy
-//     pub(crate) fn new(word_count: WordCount) -> Self {
-//         let generated_key: GeneratedKey<_, BareCtx> =
-//             BdkMnemonic::generate((word_count, Language::English)).unwrap();
-//         let mnemonic = BdkMnemonic::parse_in(Language::English, generated_key.to_string()).unwrap();
-//         Mnemonic { inner: mnemonic }
-//     }
-//
-//     /// Parse a Mnemonic with given string
-//     pub(crate) fn from_string(mnemonic: String) -> Result<Self, BdkError> {
-//         BdkMnemonic::from_str(&mnemonic)
-//             .map(|m| Mnemonic { inner: m })
-//             .map_err(|e| BdkError::Generic(e.to_string()))
-//     }
-//
-//     /// Create a new Mnemonic in the specified language from the given entropy.
-//     /// Entropy must be a multiple of 32 bits (4 bytes) and 128-256 bits in length.
-//     pub(crate) fn from_entropy(entropy: Vec<u8>) -> Result<Self, BdkError> {
-//         BdkMnemonic::from_entropy(entropy.as_slice())
-//             .map(|m| Mnemonic { inner: m })
-//             .map_err(|e| BdkError::Generic(e.to_string()))
-//     }
-//
-//     /// Returns Mnemonic as string
-//     pub(crate) fn as_string(&self) -> String {
-//         self.inner.to_string()
-//     }
-// }
-//
-// pub(crate) struct DerivationPath {
-//     inner_mutex: Mutex<BdkDerivationPath>,
-// }
-//
-// impl DerivationPath {
-//     pub(crate) fn new(path: String) -> Result<Self, BdkError> {
-//         BdkDerivationPath::from_str(&path)
-//             .map(|x| DerivationPath {
-//                 inner_mutex: Mutex::new(x),
-//             })
-//             .map_err(|e| BdkError::Generic(e.to_string()))
-//     }
-// }
-//
-// #[derive(Debug)]
-// pub(crate) struct DescriptorSecretKey {
-//     pub(crate) inner: BdkDescriptorSecretKey,
-// }
-//
-// impl DescriptorSecretKey {
-//     pub(crate) fn new(network: Network, mnemonic: Arc<Mnemonic>, password: Option<String>) -> Self {
-//         let mnemonic = mnemonic.inner.clone();
-//         let xkey: ExtendedKey = (mnemonic, password).into_extended_key().unwrap();
-//         let descriptor_secret_key = BdkDescriptorSecretKey::XPrv(DescriptorXKey {
-//             origin: None,
-//             xkey: xkey.into_xprv(network).unwrap(),
-//             derivation_path: BdkDerivationPath::master(),
-//             wildcard: bdk::descriptor::Wildcard::Unhardened,
-//         });
-//         Self {
-//             inner: descriptor_secret_key,
-//         }
-//     }
-//
-//     pub(crate) fn from_string(private_key: String) -> Result<Self, BdkError> {
-//         let descriptor_secret_key = BdkDescriptorSecretKey::from_str(private_key.as_str())
-//             .map_err(|e| BdkError::Generic(e.to_string()))?;
-//         Ok(Self {
-//             inner: descriptor_secret_key,
-//         })
-//     }
-//
-//     pub(crate) fn derive(&self, path: Arc<DerivationPath>) -> Result<Arc<Self>, BdkError> {
-//         let secp = Secp256k1::new();
-//         let descriptor_secret_key = &self.inner;
-//         let path = path.inner_mutex.lock().unwrap().deref().clone();
-//         match descriptor_secret_key {
-//             BdkDescriptorSecretKey::XPrv(descriptor_x_key) => {
-//                 let derived_xprv = descriptor_x_key.xkey.derive_priv(&secp, &path)?;
-//                 let key_source = match descriptor_x_key.origin.clone() {
-//                     Some((fingerprint, origin_path)) => (fingerprint, origin_path.extend(path)),
-//                     None => (descriptor_x_key.xkey.fingerprint(&secp), path),
-//                 };
-//                 let derived_descriptor_secret_key = BdkDescriptorSecretKey::XPrv(DescriptorXKey {
-//                     origin: Some(key_source),
-//                     xkey: derived_xprv,
-//                     derivation_path: BdkDerivationPath::default(),
-//                     wildcard: descriptor_x_key.wildcard,
-//                 });
-//                 Ok(Arc::new(Self {
-//                     inner: derived_descriptor_secret_key,
-//                 }))
-//             }
-//             BdkDescriptorSecretKey::Single(_) => Err(BdkError::Generic(
-//                 "Cannot derive from a single key".to_string(),
-//             )),
-//         }
-//     }
-//
-//     pub(crate) fn extend(&self, path: Arc<DerivationPath>) -> Result<Arc<Self>, BdkError> {
-//         let descriptor_secret_key = &self.inner;
-//         let path = path.inner_mutex.lock().unwrap().deref().clone();
-//         match descriptor_secret_key {
-//             BdkDescriptorSecretKey::XPrv(descriptor_x_key) => {
-//                 let extended_path = descriptor_x_key.derivation_path.extend(path);
-//                 let extended_descriptor_secret_key = BdkDescriptorSecretKey::XPrv(DescriptorXKey {
-//                     origin: descriptor_x_key.origin.clone(),
-//                     xkey: descriptor_x_key.xkey,
-//                     derivation_path: extended_path,
-//                     wildcard: descriptor_x_key.wildcard,
-//                 });
-//                 Ok(Arc::new(Self {
-//                     inner: extended_descriptor_secret_key,
-//                 }))
-//             }
-//             BdkDescriptorSecretKey::Single(_) => Err(BdkError::Generic(
-//                 "Cannot extend from a single key".to_string(),
-//             )),
-//         }
-//     }
-//
-//     pub(crate) fn as_public(&self) -> Arc<DescriptorPublicKey> {
-//         let secp = Secp256k1::new();
-//         let descriptor_public_key = self.inner.to_public(&secp).unwrap();
-//         Arc::new(DescriptorPublicKey {
-//             inner: descriptor_public_key,
-//         })
-//     }
-//
-//     /// Get the private key as bytes.
-//     pub(crate) fn secret_bytes(&self) -> Vec<u8> {
-//         let inner = &self.inner;
-//         let secret_bytes: Vec<u8> = match inner.deref() {
-//             BdkDescriptorSecretKey::XPrv(descriptor_x_key) => {
-//                 descriptor_x_key.xkey.private_key.secret_bytes().to_vec()
-//             }
-//             BdkDescriptorSecretKey::Single(_) => {
-//                 unreachable!()
-//             }
-//         };
-//
-//         secret_bytes
-//     }
-//
-//     pub(crate) fn as_string(&self) -> String {
-//         self.inner.to_string()
-//     }
-// }
-//
-// #[derive(Debug)]
-// pub(crate) struct DescriptorPublicKey {
-//     pub(crate) inner: BdkDescriptorPublicKey,
-// }
-//
-// impl DescriptorPublicKey {
-//     pub(crate) fn from_string(public_key: String) -> Result<Self, BdkError> {
-//         let descriptor_public_key = BdkDescriptorPublicKey::from_str(public_key.as_str())
-//             .map_err(|e| BdkError::Generic(e.to_string()))?;
-//         Ok(Self {
-//             inner: descriptor_public_key,
-//         })
-//     }
-//
-//     pub(crate) fn derive(&self, path: Arc<DerivationPath>) -> Result<Arc<Self>, BdkError> {
-//         let secp = Secp256k1::new();
-//         let descriptor_public_key = &self.inner;
-//         let path = path.inner_mutex.lock().unwrap().deref().clone();
-//
-//         match descriptor_public_key.deref() {
-//             BdkDescriptorPublicKey::XPub(descriptor_x_key) => {
-//                 let derived_xpub = descriptor_x_key.xkey.derive_pub(&secp, &path)?;
-//                 let key_source = match descriptor_x_key.origin.clone() {
-//                     Some((fingerprint, origin_path)) => (fingerprint, origin_path.extend(path)),
-//                     None => (descriptor_x_key.xkey.fingerprint(), path),
-//                 };
-//                 let derived_descriptor_public_key = BdkDescriptorPublicKey::XPub(DescriptorXKey {
-//                     origin: Some(key_source),
-//                     xkey: derived_xpub,
-//                     derivation_path: BdkDerivationPath::default(),
-//                     wildcard: descriptor_x_key.wildcard,
-//                 });
-//                 Ok(Arc::new(Self {
-//                     inner: derived_descriptor_public_key,
-//                 }))
-//             }
-//             BdkDescriptorPublicKey::Single(_) => Err(BdkError::Generic(
-//                 "Cannot derive from a single key".to_string(),
-//             )),
-//         }
-//     }
-//
-//     pub(crate) fn extend(&self, path: Arc<DerivationPath>) -> Result<Arc<Self>, BdkError> {
-//         let descriptor_public_key = &self.inner;
-//         let path = path.inner_mutex.lock().unwrap().deref().clone();
-//         match descriptor_public_key.deref() {
-//             BdkDescriptorPublicKey::XPub(descriptor_x_key) => {
-//                 let extended_path = descriptor_x_key.derivation_path.extend(path);
-//                 let extended_descriptor_public_key = BdkDescriptorPublicKey::XPub(DescriptorXKey {
-//                     origin: descriptor_x_key.origin.clone(),
-//                     xkey: descriptor_x_key.xkey,
-//                     derivation_path: extended_path,
-//                     wildcard: descriptor_x_key.wildcard,
-//                 });
-//                 Ok(Arc::new(Self {
-//                     inner: extended_descriptor_public_key,
-//                 }))
-//             }
-//             BdkDescriptorPublicKey::Single(_) => Err(BdkError::Generic(
-//                 "Cannot extend from a single key".to_string(),
-//             )),
-//         }
-//     }
-//
-//     pub(crate) fn as_string(&self) -> String {
-//         self.inner.to_string()
-//     }
-// }
-//
 // // The goal of these tests to to ensure `bdk-ffi` intermediate code correctly calls `bdk` APIs.
 // // These tests should not be used to verify `bdk` behavior that is already tested in the `bdk`
 // // crate.
diff --git a/bdk-ffi/src/lib.rs b/bdk-ffi/src/lib.rs
index 68312c7f..4189daa1 100644
--- a/bdk-ffi/src/lib.rs
+++ b/bdk-ffi/src/lib.rs
@@ -47,170 +47,16 @@ mod descriptor;
 mod keys;
 mod psbt;
 mod wallet;
-//
-// use crate::blockchain::{
-//     Auth, Blockchain, BlockchainConfig, ElectrumConfig, EsploraConfig, RpcConfig, RpcSyncParams,
-// };
-// use crate::database::DatabaseConfig;
-// use crate::descriptor::Descriptor;
-use crate::keys::DerivationPath;
-// use crate::keys::{DescriptorPublicKey, DescriptorSecretKey, Mnemonic};
-// use crate::psbt::PartiallySignedTransaction;
-// use crate::wallet::SignOptions;
-// use crate::wallet::{BumpFeeTxBuilder, TxBuilder, Wallet};
-// use bdk::bitcoin::blockdata::script::Script as BdkScript;
-// use bdk::bitcoin::blockdata::transaction::TxIn as BdkTxIn;
-// use bdk::bitcoin::blockdata::transaction::TxOut as BdkTxOut;
-// use bdk::bitcoin::consensus::Decodable;
-// use bdk::bitcoin::psbt::serialize::Serialize;
-// use bdk::bitcoin::util::address::{Payload as BdkPayload, WitnessVersion};
-// use bdk::bitcoin::{
-//     Address as BdkAddress, Network, OutPoint as BdkOutPoint, Transaction as BdkTransaction, Txid,
-// };
-// use bdk::blockchain::Progress as BdkProgress;
-// use bdk::database::any::{SledDbConfiguration, SqliteDbConfiguration};
-use bdk::keys::bip39::WordCount;
-// use bdk::wallet::AddressIndex as BdkAddressIndex;
-// use bdk::wallet::AddressInfo as BdkAddressInfo;
-// use bdk::LocalUtxo as BdkLocalUtxo;
-// use bdk::TransactionDetails as BdkTransactionDetails;
-// use bdk::{Balance as BdkBalance, BlockTime, Error as BdkError, FeeRate, KeychainKind};
+
 use crate::descriptor::Descriptor;
+use crate::keys::DerivationPath;
 use crate::keys::DescriptorPublicKey;
 use crate::keys::DescriptorSecretKey;
 use crate::keys::Mnemonic;
+use bdk::keys::bip39::WordCount;
 use bdk::Error as BdkError;
 use bdk::KeychainKind;
 
-// use std::convert::From;
-// use std::fmt;
-// use std::fmt::Debug;
-// use std::io::Cursor;
-// use std::str::FromStr;
-// use std::sync::Arc;
-//
-// uniffi::include_scaffolding!("bdk");
-//
-// /// A output script and an amount of satoshis.
-// pub struct ScriptAmount {
-//     pub script: Arc<Script>,
-//     pub amount: u64,
-// }
-//
-// /// A derived address and the index it was found at.
-// pub struct AddressInfo {
-//     /// Child index of this address.
-//     pub index: u32,
-//     /// Address.
-//     pub address: Arc<Address>,
-//     /// Type of keychain.
-//     pub keychain: KeychainKind,
-// }
-//
-// impl From<BdkAddressInfo> for AddressInfo {
-//     fn from(address_info: BdkAddressInfo) -> Self {
-//         AddressInfo {
-//             index: address_info.index,
-//             address: Arc::new(Address::from(address_info.address)),
-//             keychain: address_info.keychain,
-//         }
-//     }
-// }
-//
-// /// The address index selection strategy to use to derived an address from the wallet's external
-// /// descriptor.
-// pub enum AddressIndex {
-//     /// Return a new address after incrementing the current descriptor index.
-//     New,
-//     /// Return the address for the current descriptor index if it has not been used in a received
-//     /// transaction. Otherwise return a new address as with AddressIndex::New.
-//     /// Use with caution, if the wallet has not yet detected an address has been used it could
-//     /// return an already used address. This function is primarily meant for situations where the
-//     /// caller is untrusted; for example when deriving donation addresses on-demand for a public
-//     /// web page.
-//     LastUnused,
-//     /// Return the address for a specific descriptor index. Does not change the current descriptor
-//     /// index used by `AddressIndex::New` and `AddressIndex::LastUsed`.
-//     /// Use with caution, if an index is given that is less than the current descriptor index
-//     /// then the returned address may have already been used.
-//     Peek { index: u32 },
-//     /// Return the address for a specific descriptor index and reset the current descriptor index
-//     /// used by `AddressIndex::New` and `AddressIndex::LastUsed` to this value.
-//     /// Use with caution, if an index is given that is less than the current descriptor index
-//     /// then the returned address and subsequent addresses returned by calls to `AddressIndex::New`
-//     /// and `AddressIndex::LastUsed` may have already been used. Also if the index is reset to a
-//     /// value earlier than the [`Blockchain`] stop_gap (default is 20) then a
-//     /// larger stop_gap should be used to monitor for all possibly used addresses.
-//     Reset { index: u32 },
-// }
-//
-// impl From<AddressIndex> for BdkAddressIndex {
-//     fn from(address_index: AddressIndex) -> Self {
-//         match address_index {
-//             AddressIndex::New => BdkAddressIndex::New,
-//             AddressIndex::LastUnused => BdkAddressIndex::LastUnused,
-//             AddressIndex::Peek { index } => BdkAddressIndex::Peek(index),
-//             AddressIndex::Reset { index } => BdkAddressIndex::Reset(index),
-//         }
-//     }
-// }
-//
-// /// A wallet transaction
-// #[derive(Debug, Clone, PartialEq, Eq, Default)]
-// pub struct TransactionDetails {
-//     pub transaction: Option<Arc<Transaction>>,
-//     /// Transaction id.
-//     pub txid: String,
-//     /// Received value (sats)
-//     /// Sum of owned outputs of this transaction.
-//     pub received: u64,
-//     /// Sent value (sats)
-//     /// Sum of owned inputs of this transaction.
-//     pub sent: u64,
-//     /// Fee value (sats) if confirmed.
-//     /// The availability of the fee depends on the backend. It's never None with an Electrum
-//     /// Server backend, but it could be None with a Bitcoin RPC node without txindex that receive
-//     /// funds while offline.
-//     pub fee: Option<u64>,
-//     /// If the transaction is confirmed, contains height and timestamp of the block containing the
-//     /// transaction, unconfirmed transaction contains `None`.
-//     pub confirmation_time: Option<BlockTime>,
-// }
-//
-// impl From<BdkTransactionDetails> for TransactionDetails {
-//     fn from(tx_details: BdkTransactionDetails) -> Self {
-//         let optional_tx: Option<Arc<Transaction>> =
-//             tx_details.transaction.map(|tx| Arc::new(tx.into()));
-//
-//         TransactionDetails {
-//             transaction: optional_tx,
-//             fee: tx_details.fee,
-//             txid: tx_details.txid.to_string(),
-//             received: tx_details.received,
-//             sent: tx_details.sent,
-//             confirmation_time: tx_details.confirmation_time,
-//         }
-//     }
-// }
-//
-// /// A reference to a transaction output.
-// #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-// pub struct OutPoint {
-//     /// The referenced transaction's txid.
-//     txid: String,
-//     /// The index of the referenced output in its transaction's vout.
-//     vout: u32,
-// }
-//
-// impl From<&OutPoint> for BdkOutPoint {
-//     fn from(outpoint: &OutPoint) -> Self {
-//         BdkOutPoint {
-//             txid: Txid::from_str(&outpoint.txid).unwrap(),
-//             vout: outpoint.vout,
-//         }
-//     }
-// }
-
 pub struct Balance {
     pub inner: BdkBalance,
 }
@@ -247,211 +93,13 @@ impl Balance {
     }
 }
 
-// pub struct Balance {
-//     // All coinbase outputs not yet matured
-//     pub immature: u64,
-//     /// Unconfirmed UTXOs generated by a wallet tx
-//     pub trusted_pending: u64,
-//     /// Unconfirmed UTXOs received from an external wallet
-//     pub untrusted_pending: u64,
-//     /// Confirmed and immediately spendable balance
-//     pub confirmed: u64,
-//     /// Get sum of trusted_pending and confirmed coins
-//     pub spendable: u64,
-//     /// Get the whole balance visible to the wallet
-//     pub total: u64,
-// }
-//
-// impl From<BdkBalance> for Balance {
-//     fn from(bdk_balance: BdkBalance) -> Self {
-//         Balance {
-//             immature: bdk_balance.immature,
-//             trusted_pending: bdk_balance.trusted_pending,
-//             untrusted_pending: bdk_balance.untrusted_pending,
-//             confirmed: bdk_balance.confirmed,
-//             spendable: bdk_balance.get_spendable(),
-//             total: bdk_balance.get_total(),
-//         }
-//     }
-// }
-//
-// /// A transaction output, which defines new coins to be created from old ones.
-// #[derive(Debug, Clone)]
-// pub struct TxOut {
-//     /// The value of the output, in satoshis.
-//     value: u64,
-//     /// The address of the output.
-//     script_pubkey: Arc<Script>,
-// }
-//
-// impl From<&BdkTxOut> for TxOut {
-//     fn from(tx_out: &BdkTxOut) -> Self {
-//         TxOut {
-//             value: tx_out.value,
-//             script_pubkey: Arc::new(Script {
-//                 inner: tx_out.script_pubkey.clone(),
-//             }),
-//         }
-//     }
-// }
-//
-// pub struct LocalUtxo {
-//     outpoint: OutPoint,
-//     txout: TxOut,
-//     keychain: KeychainKind,
-//     is_spent: bool,
-// }
-//
-// impl From<BdkLocalUtxo> for LocalUtxo {
-//     fn from(local_utxo: BdkLocalUtxo) -> Self {
-//         LocalUtxo {
-//             outpoint: OutPoint {
-//                 txid: local_utxo.outpoint.txid.to_string(),
-//                 vout: local_utxo.outpoint.vout,
-//             },
-//             txout: TxOut {
-//                 value: local_utxo.txout.value,
-//                 script_pubkey: Arc::new(Script {
-//                     inner: local_utxo.txout.script_pubkey,
-//                 }),
-//             },
-//             keychain: local_utxo.keychain,
-//             is_spent: local_utxo.is_spent,
-//         }
-//     }
-// }
-//
-// /// Trait that logs at level INFO every update received (if any).
-// pub trait Progress: Send + Sync + 'static {
-//     /// Send a new progress update. The progress value should be in the range 0.0 - 100.0, and the message value is an
-//     /// optional text message that can be displayed to the user.
-//     fn update(&self, progress: f32, message: Option<String>);
-// }
-//
-// struct ProgressHolder {
-//     progress: Box<dyn Progress>,
-// }
-//
-// impl BdkProgress for ProgressHolder {
-//     fn update(&self, progress: f32, message: Option<String>) -> Result<(), BdkError> {
-//         self.progress.update(progress, message);
-//         Ok(())
-//     }
-// }
-//
-// impl Debug for ProgressHolder {
-//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-//         f.debug_struct("ProgressHolder").finish_non_exhaustive()
-//     }
-// }
-//
-// #[derive(Debug, Clone)]
-// pub struct TxIn {
-//     pub previous_output: OutPoint,
-//     pub script_sig: Arc<Script>,
-//     pub sequence: u32,
-//     pub witness: Vec<Vec<u8>>,
-// }
-//
-// impl From<&BdkTxIn> for TxIn {
-//     fn from(tx_in: &BdkTxIn) -> Self {
-//         TxIn {
-//             previous_output: OutPoint {
-//                 txid: tx_in.previous_output.txid.to_string(),
-//                 vout: tx_in.previous_output.vout,
-//             },
-//             script_sig: Arc::new(Script {
-//                 inner: tx_in.script_sig.clone(),
-//             }),
-//             sequence: tx_in.sequence.0,
-//             witness: tx_in.witness.to_vec(),
-//         }
-//     }
-// }
-//
-// /// A Bitcoin transaction.
-// #[derive(Debug, Clone, PartialEq, Eq)]
-// pub struct Transaction {
-//     inner: BdkTransaction,
-// }
-//
-// impl Transaction {
-//     fn new(transaction_bytes: Vec<u8>) -> Result<Self, BdkError> {
-//         let mut decoder = Cursor::new(transaction_bytes);
-//         let tx: BdkTransaction = BdkTransaction::consensus_decode(&mut decoder)?;
-//         Ok(Transaction { inner: tx })
-//     }
-//
-//     fn txid(&self) -> String {
-//         self.inner.txid().to_string()
-//     }
-//
-//     fn weight(&self) -> u64 {
-//         self.inner.weight() as u64
-//     }
-//
-//     fn size(&self) -> u64 {
-//         self.inner.size() as u64
-//     }
-//
-//     fn vsize(&self) -> u64 {
-//         self.inner.vsize() as u64
-//     }
-//
-//     fn serialize(&self) -> Vec<u8> {
-//         self.inner.serialize()
-//     }
-//
-//     fn is_coin_base(&self) -> bool {
-//         self.inner.is_coin_base()
-//     }
-//
-//     fn is_explicitly_rbf(&self) -> bool {
-//         self.inner.is_explicitly_rbf()
-//     }
-//
-//     fn is_lock_time_enabled(&self) -> bool {
-//         self.inner.is_lock_time_enabled()
-//     }
-//
-//     fn version(&self) -> i32 {
-//         self.inner.version
-//     }
-//
-//     fn lock_time(&self) -> u32 {
-//         self.inner.lock_time.0
-//     }
-//
-//     fn input(&self) -> Vec<TxIn> {
-//         self.inner.input.iter().map(|x| x.into()).collect()
-//     }
-//
-//     fn output(&self) -> Vec<TxOut> {
-//         self.inner.output.iter().map(|x| x.into()).collect()
-//     }
-// }
-//
-// impl From<BdkTransaction> for Transaction {
-//     fn from(tx: BdkTransaction) -> Self {
-//         Transaction { inner: tx }
-//     }
-// }
-//
-// /// A Bitcoin address.
-// #[derive(Debug, PartialEq, Eq)]
-// pub struct Address {
-//     inner: BdkAddress,
-// }
-//
-
-use std::sync::Arc;
-
 use crate::wallet::Wallet;
 use crate::wallet::WalletType;
 use bdk::bitcoin::address::{NetworkChecked, NetworkUnchecked};
 use bdk::bitcoin::Address as BdkAddress;
 use bdk::wallet::AddressIndex as BdkAddressIndex;
 use bdk::wallet::AddressInfo as BdkAddressInfo;
+use std::sync::Arc;
 /// A derived address and the index it was found at.
 pub struct AddressInfo {
     /// Child index of this address.
@@ -517,10 +165,6 @@ impl Address {
                 .map_err(|e| BdkError::Generic(e.to_string()))?,
         })
     }
-    // fn to_qr_uri(&self) -> String {
-    //     self.inner.to_qr_uri()
-    // }
-
     fn as_string(&self) -> String {
         self.inner.to_string()
     }
@@ -542,114 +186,6 @@ impl From<Address> for BdkAddress {
     }
 }
 
-// impl Address {
-//     fn new(address: String) -> Result<Self, BdkError> {
-//         BdkAddress::from_str(address.as_str())
-//             .map(|a| Address { inner: a })
-//             .map_err(|e| BdkError::Generic(e.to_string()))
-//     }
-//
-//     /// alternative constructor
-//     fn from_script(script: Arc<Script>, network: Network) -> Result<Self, BdkError> {
-//         BdkAddress::from_script(&script.inner, network)
-//             .map(|a| Address { inner: a })
-//             .map_err(|e| BdkError::Generic(e.to_string()))
-//     }
-//
-//     fn payload(&self) -> Payload {
-//         match &self.inner.payload.clone() {
-//             BdkPayload::PubkeyHash(pubkey_hash) => Payload::PubkeyHash {
-//                 pubkey_hash: pubkey_hash.to_vec(),
-//             },
-//             BdkPayload::ScriptHash(script_hash) => Payload::ScriptHash {
-//                 script_hash: script_hash.to_vec(),
-//             },
-//             BdkPayload::WitnessProgram { version, program } => Payload::WitnessProgram {
-//                 version: *version,
-//                 program: program.clone(),
-//             },
-//         }
-//     }
-//
-//     fn network(&self) -> Network {
-//         self.inner.network
-//     }
-//
-//     fn script_pubkey(&self) -> Arc<Script> {
-//         Arc::new(Script {
-//             inner: self.inner.script_pubkey(),
-//         })
-//     }
-//
-//     fn to_qr_uri(&self) -> String {
-//         self.inner.to_qr_uri()
-//     }
-//
-//     fn as_string(&self) -> String {
-//         self.inner.to_string()
-//     }
-// }
-//
-// impl From<BdkAddress> for Address {
-//     fn from(address: BdkAddress) -> Self {
-//         Address { inner: address }
-//     }
-// }
-//
-// /// The method used to produce an address.
-// #[derive(Debug)]
-// pub enum Payload {
-//     /// P2PKH address.
-//     PubkeyHash { pubkey_hash: Vec<u8> },
-//     /// P2SH address.
-//     ScriptHash { script_hash: Vec<u8> },
-//     /// Segwit address.
-//     WitnessProgram {
-//         /// The witness program version.
-//         version: WitnessVersion,
-//         /// The witness program.
-//         program: Vec<u8>,
-//     },
-// }
-//
-// /// A Bitcoin script.
-// #[derive(Clone, Debug, PartialEq, Eq)]
-// pub struct Script {
-//     inner: BdkScript,
-// }
-//
-// impl Script {
-//     fn new(raw_output_script: Vec<u8>) -> Self {
-//         let script: BdkScript = BdkScript::from(raw_output_script);
-//         Script { inner: script }
-//     }
-//
-//     fn to_bytes(&self) -> Vec<u8> {
-//         self.inner.to_bytes()
-//     }
-// }
-//
-// impl From<BdkScript> for Script {
-//     fn from(bdk_script: BdkScript) -> Self {
-//         Script { inner: bdk_script }
-//     }
-// }
-//
-// #[derive(Clone, Debug)]
-// enum RbfValue {
-//     Default,
-//     Value(u32),
-// }
-//
-// /// The result after calling the TxBuilder finish() function. Contains unsigned PSBT and
-// /// transaction details.
-// pub struct TxBuilderResult {
-//     pub(crate) psbt: Arc<PartiallySignedTransaction>,
-//     pub transaction_details: TransactionDetails,
-// }
-//
-// uniffi::deps::static_assertions::assert_impl_all!(Wallet: Sync, Send);
-//
 // // The goal of these tests to to ensure `bdk-ffi` intermediate code correctly calls `bdk` APIs.
 // // These tests should not be used to verify `bdk` behavior that is already tested in the `bdk`
 // // crate.
diff --git a/bdk-ffi/src/psbt.rs b/bdk-ffi/src/psbt.rs
index b27ad2ca..28704ea3 100644
--- a/bdk-ffi/src/psbt.rs
+++ b/bdk-ffi/src/psbt.rs
@@ -1,82 +1,3 @@
-// use bdk::bitcoin::hashes::hex::ToHex;
-// use bdk::bitcoin::util::psbt::PartiallySignedTransaction as BdkPartiallySignedTransaction;
-// use bdk::bitcoincore_rpc::jsonrpc::serde_json;
-// use bdk::psbt::PsbtUtils;
-// use std::ops::Deref;
-// use std::str::FromStr;
-// use std::sync::{Arc, Mutex};
-//
-// use crate::{BdkError, FeeRate, Transaction};
-// use crate::BdkError;
-//
-// #[derive(Debug)]
-// pub(crate) struct PartiallySignedTransaction {
-//     pub(crate) inner: Mutex<BdkPartiallySignedTransaction>,
-// }
-//
-// impl PartiallySignedTransaction {
-//     pub(crate) fn new(psbt_base64: String) -> Result<Self, BdkError> {
-//         let psbt: BdkPartiallySignedTransaction =
-//             BdkPartiallySignedTransaction::from_str(&psbt_base64)?;
-//         Ok(PartiallySignedTransaction {
-//             inner: Mutex::new(psbt),
-//         })
-//     }
-//
-//     pub(crate) fn serialize(&self) -> String {
-//         let psbt = self.inner.lock().unwrap().clone();
-//         psbt.to_string()
-//     }
-//
-//     pub(crate) fn txid(&self) -> String {
-//         let tx = self.inner.lock().unwrap().clone().extract_tx();
-//         let txid = tx.txid();
-//         txid.to_hex()
-//     }
-//
-//     /// Return the transaction.
-//     pub(crate) fn extract_tx(&self) -> Arc<Transaction> {
-//         let tx = self.inner.lock().unwrap().clone().extract_tx();
-//         Arc::new(tx.into())
-//     }
-//
-//     /// Combines this PartiallySignedTransaction with other PSBT as described by BIP 174.
-//     ///
-//     /// In accordance with BIP 174 this function is commutative i.e., `A.combine(B) == B.combine(A)`
-//     pub(crate) fn combine(
-//         &self,
-//         other: Arc<PartiallySignedTransaction>,
-//     ) -> Result<Arc<PartiallySignedTransaction>, BdkError> {
-//         let other_psbt = other.inner.lock().unwrap().clone();
-//         let mut original_psbt = self.inner.lock().unwrap().clone();
-//
-//         original_psbt.combine(other_psbt)?;
-//         Ok(Arc::new(PartiallySignedTransaction {
-//             inner: Mutex::new(original_psbt),
-//         }))
-//     }
-//
-//     /// The total transaction fee amount, sum of input amounts minus sum of output amounts, in Sats.
-//     /// If the PSBT is missing a TxOut for an input returns None.
-//     pub(crate) fn fee_amount(&self) -> Option<u64> {
-//         self.inner.lock().unwrap().fee_amount()
-//     }
-//
-//     /// The transaction's fee rate. This value will only be accurate if calculated AFTER the
-//     /// `PartiallySignedTransaction` is finalized and all witness/signature data is added to the
-//     /// transaction.
-//     /// If the PSBT is missing a TxOut for an input returns None.
-//     pub(crate) fn fee_rate(&self) -> Option<Arc<FeeRate>> {
-//         self.inner.lock().unwrap().fee_rate().map(Arc::new)
-//     }
-//
-//     /// Serialize the PSBT data structure as a String of JSON.
-//     pub(crate) fn json_serialize(&self) -> String {
-//         let psbt = self.inner.lock().unwrap();
-//         serde_json::to_string(psbt.deref()).unwrap()
-//     }
-// }
-//
 // // The goal of these tests to to ensure `bdk-ffi` intermediate code correctly calls `bdk` APIs.
 // // These tests should not be used to verify `bdk` behavior that is already tested in the `bdk`
 // // crate.
diff --git a/bdk-ffi/src/wallet.rs b/bdk-ffi/src/wallet.rs
index a7441d2c..ababc7a6 100644
--- a/bdk-ffi/src/wallet.rs
+++ b/bdk-ffi/src/wallet.rs
@@ -1,565 +1,3 @@
-// use bdk::bitcoin::blockdata::script::Script as BdkScript;
-// use bdk::bitcoin::{Address as BdkAddress, Network, OutPoint as BdkOutPoint, Sequence, Txid};
-// use bdk::database::any::AnyDatabase;
-// use bdk::database::{AnyDatabaseConfig, ConfigurableDatabase};
-// use bdk::wallet::tx_builder::ChangeSpendPolicy;
-// use bdk::{
-//     FeeRate, LocalUtxo as BdkLocalUtxo, SignOptions as BdkSignOptions,
-//     SyncOptions as BdkSyncOptions, Wallet as BdkWallet,
-// };
-// use std::collections::HashSet;
-// use std::ops::Deref;
-// use std::str::FromStr;
-// use std::sync::{Arc, Mutex, MutexGuard};
-//
-// use crate::blockchain::Blockchain;
-// use crate::database::DatabaseConfig;
-// use crate::descriptor::Descriptor;
-// use crate::psbt::PartiallySignedTransaction;
-// use crate::{
-//     AddressIndex, AddressInfo, Balance, BdkError, LocalUtxo, OutPoint, Progress, ProgressHolder,
-//     RbfValue, Script, ScriptAmount, TransactionDetails, TxBuilderResult,
-// };
-//
-// #[derive(Debug)]
-// pub(crate) struct Wallet {
-//     pub(crate) inner_mutex: Mutex<BdkWallet<AnyDatabase>>,
-// }
-//
-// /// A Bitcoin wallet.
-// /// The Wallet acts as a way of coherently interfacing with output descriptors and related transactions. Its main components are:
-// ///     1. Output descriptors from which it can derive addresses.
-// ///     2. A Database where it tracks transactions and utxos related to the descriptors.
-// ///     3. Signers that can contribute signatures to addresses instantiated from the descriptors.
-// impl Wallet {
-//     pub(crate) fn new(
-//         descriptor: Arc<Descriptor>,
-//         change_descriptor: Option<Arc<Descriptor>>,
-//         network: Network,
-//         database_config: DatabaseConfig,
-//     ) -> Result<Self, BdkError> {
-//         let any_database_config = match database_config {
-//             DatabaseConfig::Memory => AnyDatabaseConfig::Memory(()),
-//             DatabaseConfig::Sled { config } => AnyDatabaseConfig::Sled(config),
-//             DatabaseConfig::Sqlite { config } => AnyDatabaseConfig::Sqlite(config),
-//         };
-//         let database = AnyDatabase::from_config(&any_database_config)?;
-//         let descriptor: String = descriptor.as_string_private();
-//         let change_descriptor: Option<String> = change_descriptor.map(|d| d.as_string_private());
-//
-//         let wallet_mutex = Mutex::new(BdkWallet::new(
-//             &descriptor,
-//             change_descriptor.as_ref(),
-//             network,
-//             database,
-//         )?);
-//         Ok(Wallet {
-//             inner_mutex: wallet_mutex,
-//         })
-//     }
-//
-//     pub(crate) fn get_wallet(&self) -> MutexGuard<BdkWallet<AnyDatabase>> {
-//         self.inner_mutex.lock().expect("wallet")
-//     }
-//
-//     /// Get the Bitcoin network the wallet is using.
-//     pub(crate) fn network(&self) -> Network {
-//         self.get_wallet().network()
-//     }
-//
-//     /// Return whether or not a script is part of this wallet (either internal or external).
-//     pub(crate) fn is_mine(&self, script: Arc<Script>) -> Result<bool, BdkError> {
-//         self.get_wallet().is_mine(&script.inner)
-//     }
-//
-//     /// Sync the internal database with the blockchain.
-//     pub(crate) fn sync(
-//         &self,
-//         blockchain: &Blockchain,
-//         progress: Option<Box<dyn Progress>>,
-//     ) -> Result<(), BdkError> {
-//         let bdk_sync_opts = BdkSyncOptions {
-//             progress: progress.map(|p| {
-//                 Box::new(ProgressHolder { progress: p })
-//                     as Box<(dyn bdk::blockchain::Progress + 'static)>
-//             }),
-//         };
-//
-//         let blockchain = blockchain.get_blockchain();
-//         self.get_wallet().sync(blockchain.deref(), bdk_sync_opts)
-//     }
-//
-//     /// Return a derived address using the external descriptor, see AddressIndex for available address index selection
-//     /// strategies. If none of the keys in the descriptor are derivable (i.e. the descriptor does not end with a * character)
-//     /// then the same address will always be returned for any AddressIndex.
-//     pub(crate) fn get_address(&self, address_index: AddressIndex) -> Result<AddressInfo, BdkError> {
-//         self.get_wallet()
-//             .get_address(address_index.into())
-//             .map(AddressInfo::from)
-//     }
-//
-//     /// Return a derived address using the internal (change) descriptor.
-//     ///
-//     /// If the wallet doesn't have an internal descriptor it will use the external descriptor.
-//     ///
-//     /// see [`AddressIndex`] for available address index selection strategies. If none of the keys
-//     /// in the descriptor are derivable (i.e. does not end with /*) then the same address will always
-//     /// be returned for any [`AddressIndex`].
-//     pub(crate) fn get_internal_address(
-//         &self,
-//         address_index: AddressIndex,
-//     ) -> Result<AddressInfo, BdkError> {
-//         self.get_wallet()
-//             .get_internal_address(address_index.into())
-//             .map(AddressInfo::from)
-//     }
-//
-//     /// Return the balance, meaning the sum of this wallet’s unspent outputs’ values. Note that this method only operates
-//     /// on the internal database, which first needs to be Wallet.sync manually.
-//     pub(crate) fn get_balance(&self) -> Result<Balance, BdkError> {
-//         self.get_wallet().get_balance().map(|b| b.into())
-//     }
-//
-//     /// Sign a transaction with all the wallet's signers, in the order specified by every signer's
-//     /// [`SignerOrdering`]. This function returns the `Result` type with an encapsulated `bool` that
-//     /// has the value true if the PSBT was finalized, or false otherwise.
-//     ///
-//     /// The [`SignOptions`] can be used to tweak the behavior of the software signers, and the way
-//     /// the transaction is finalized at the end. Note that it can't be guaranteed that *every*
-//     /// signers will follow the options, but the "software signers" (WIF keys and `xprv`) defined
-//     /// in this library will.
-//     pub(crate) fn sign(
-//         &self,
-//         psbt: &PartiallySignedTransaction,
-//         sign_options: Option<SignOptions>,
-//     ) -> Result<bool, BdkError> {
-//         let mut psbt = psbt.inner.lock().unwrap();
-//         self.get_wallet().sign(
-//             &mut psbt,
-//             sign_options.map(SignOptions::into).unwrap_or_default(),
-//         )
-//     }
-//
-//     /// Return the list of transactions made and received by the wallet. Note that this method only operate on the internal database, which first needs to be [Wallet.sync] manually.
-//     pub(crate) fn list_transactions(
-//         &self,
-//         include_raw: bool,
-//     ) -> Result<Vec<TransactionDetails>, BdkError> {
-//         let transaction_details = self.get_wallet().list_transactions(include_raw)?;
-//         Ok(transaction_details
-//             .into_iter()
-//             .map(TransactionDetails::from)
-//             .collect())
-//     }
-//
-//     /// Return the list of unspent outputs of this wallet. Note that this method only operates on the internal database,
-//     /// which first needs to be Wallet.sync manually.
-//     pub(crate) fn list_unspent(&self) -> Result<Vec<LocalUtxo>, BdkError> {
-//         let unspents: Vec<BdkLocalUtxo> = self.get_wallet().list_unspent()?;
-//         Ok(unspents.into_iter().map(LocalUtxo::from).collect())
-//     }
-// }
-//
-// /// Options for a software signer
-// ///
-// /// Adjust the behavior of our software signers and the way a transaction is finalized
-// #[derive(Debug, Clone, Default)]
-// pub struct SignOptions {
-//     /// Whether the signer should trust the `witness_utxo`, if the `non_witness_utxo` hasn't been
-//     /// provided
-//     ///
-//     /// Defaults to `false` to mitigate the "SegWit bug" which should trick the wallet into
-//     /// paying a fee larger than expected.
-//     ///
-//     /// Some wallets, especially if relatively old, might not provide the `non_witness_utxo` for
-//     /// SegWit transactions in the PSBT they generate: in those cases setting this to `true`
-//     /// should correctly produce a signature, at the expense of an increased trust in the creator
-//     /// of the PSBT.
-//     ///
-//     /// For more details see: <https://blog.trezor.io/details-of-firmware-updates-for-trezor-one-version-1-9-1-and-trezor-model-t-version-2-3-1-1eba8f60f2dd>
-//     pub trust_witness_utxo: bool,
-//
-//     /// Whether the wallet should assume a specific height has been reached when trying to finalize
-//     /// a transaction
-//     ///
-//     /// The wallet will only "use" a timelock to satisfy the spending policy of an input if the
-//     /// timelock height has already been reached. This option allows overriding the "current height" to let the
-//     /// wallet use timelocks in the future to spend a coin.
-//     pub assume_height: Option<u32>,
-//
-//     /// Whether the signer should use the `sighash_type` set in the PSBT when signing, no matter
-//     /// what its value is
-//     ///
-//     /// Defaults to `false` which will only allow signing using `SIGHASH_ALL`.
-//     pub allow_all_sighashes: bool,
-//
-//     /// Whether to remove partial signatures from the PSBT inputs while finalizing PSBT.
-//     ///
-//     /// Defaults to `true` which will remove partial signatures during finalization.
-//     pub remove_partial_sigs: bool,
-//
-//     /// Whether to try finalizing the PSBT after the inputs are signed.
-//     ///
-//     /// Defaults to `true` which will try finalizing PSBT after inputs are signed.
-//     pub try_finalize: bool,
-//
-//     // Specifies which Taproot script-spend leaves we should sign for. This option is
-//     // ignored if we're signing a non-taproot PSBT.
-//     //
-//     // Defaults to All, i.e., the wallet will sign all the leaves it has a key for.
-//     // TODO pub tap_leaves_options: TapLeavesOptions,
-//     /// Whether we should try to sign a taproot transaction with the taproot internal key
-//     /// or not. This option is ignored if we're signing a non-taproot PSBT.
-//     ///
-//     /// Defaults to `true`, i.e., we always try to sign with the taproot internal key.
-//     pub sign_with_tap_internal_key: bool,
-//
-//     /// Whether we should grind ECDSA signature to ensure signing with low r
-//     /// or not.
-//     /// Defaults to `true`, i.e., we always grind ECDSA signature to sign with low r.
-//     pub allow_grinding: bool,
-// }
-//
-// impl From<SignOptions> for BdkSignOptions {
-//     fn from(sign_options: SignOptions) -> Self {
-//         BdkSignOptions {
-//             trust_witness_utxo: sign_options.trust_witness_utxo,
-//             assume_height: sign_options.assume_height,
-//             allow_all_sighashes: sign_options.allow_all_sighashes,
-//             remove_partial_sigs: sign_options.remove_partial_sigs,
-//             try_finalize: sign_options.try_finalize,
-//             tap_leaves_options: Default::default(),
-//             sign_with_tap_internal_key: sign_options.sign_with_tap_internal_key,
-//             allow_grinding: sign_options.allow_grinding,
-//         }
-//     }
-// }
-//
-// /// A transaction builder.
-// /// After creating the TxBuilder, you set options on it until finally calling finish to consume the builder and generate the transaction.
-// /// Each method on the TxBuilder returns an instance of a new TxBuilder with the option set/added.
-// #[derive(Clone, Debug)]
-// pub(crate) struct TxBuilder {
-//     pub(crate) recipients: Vec<(BdkScript, u64)>,
-//     pub(crate) utxos: Vec<OutPoint>,
-//     pub(crate) unspendable: HashSet<OutPoint>,
-//     pub(crate) change_policy: ChangeSpendPolicy,
-//     pub(crate) manually_selected_only: bool,
-//     pub(crate) fee_rate: Option<f32>,
-//     pub(crate) fee_absolute: Option<u64>,
-//     pub(crate) drain_wallet: bool,
-//     pub(crate) drain_to: Option<BdkScript>,
-//     pub(crate) rbf: Option<RbfValue>,
-//     pub(crate) data: Vec<u8>,
-// }
-//
-// impl TxBuilder {
-//     pub(crate) fn new() -> Self {
-//         TxBuilder {
-//             recipients: Vec::new(),
-//             utxos: Vec::new(),
-//             unspendable: HashSet::new(),
-//             change_policy: ChangeSpendPolicy::ChangeAllowed,
-//             manually_selected_only: false,
-//             fee_rate: None,
-//             fee_absolute: None,
-//             drain_wallet: false,
-//             drain_to: None,
-//             rbf: None,
-//             data: Vec::new(),
-//         }
-//     }
-//
-//     /// Add a recipient to the internal list.
-//     pub(crate) fn add_recipient(&self, script: Arc<Script>, amount: u64) -> Arc<Self> {
-//         let mut recipients: Vec<(BdkScript, u64)> = self.recipients.clone();
-//         recipients.append(&mut vec![(script.inner.clone(), amount)]);
-//         Arc::new(TxBuilder {
-//             recipients,
-//             ..self.clone()
-//         })
-//     }
-//
-//     pub(crate) fn set_recipients(&self, recipients: Vec<ScriptAmount>) -> Arc<Self> {
-//         let recipients = recipients
-//             .iter()
-//             .map(|script_amount| (script_amount.script.inner.clone(), script_amount.amount))
-//             .collect();
-//         Arc::new(TxBuilder {
-//             recipients,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Add a utxo to the internal list of unspendable utxos. It’s important to note that the "must-be-spent"
-//     /// utxos added with [TxBuilder.addUtxo] have priority over this. See the Rust docs of the two linked methods for more details.
-//     pub(crate) fn add_unspendable(&self, unspendable: OutPoint) -> Arc<Self> {
-//         let mut unspendable_hash_set = self.unspendable.clone();
-//         unspendable_hash_set.insert(unspendable);
-//         Arc::new(TxBuilder {
-//             unspendable: unspendable_hash_set,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Add an outpoint to the internal list of UTXOs that must be spent. These have priority over the "unspendable"
-//     /// utxos, meaning that if a utxo is present both in the "utxos" and the "unspendable" list, it will be spent.
-//     pub(crate) fn add_utxo(&self, outpoint: OutPoint) -> Arc<Self> {
-//         self.add_utxos(vec![outpoint])
-//     }
-//
-//     /// Add the list of outpoints to the internal list of UTXOs that must be spent. If an error occurs while adding
-//     /// any of the UTXOs then none of them are added and the error is returned. These have priority over the "unspendable"
-//     /// utxos, meaning that if a utxo is present both in the "utxos" and the "unspendable" list, it will be spent.
-//     pub(crate) fn add_utxos(&self, mut outpoints: Vec<OutPoint>) -> Arc<Self> {
-//         let mut utxos = self.utxos.to_vec();
-//         utxos.append(&mut outpoints);
-//         Arc::new(TxBuilder {
-//             utxos,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Do not spend change outputs. This effectively adds all the change outputs to the "unspendable" list. See TxBuilder.unspendable.
-//     pub(crate) fn do_not_spend_change(&self) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             change_policy: ChangeSpendPolicy::ChangeForbidden,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Only spend utxos added by [add_utxo]. The wallet will not add additional utxos to the transaction even if they are
-//     /// needed to make the transaction valid.
-//     pub(crate) fn manually_selected_only(&self) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             manually_selected_only: true,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Only spend change outputs. This effectively adds all the non-change outputs to the "unspendable" list. See TxBuilder.unspendable.
-//     pub(crate) fn only_spend_change(&self) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             change_policy: ChangeSpendPolicy::OnlyChange,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Replace the internal list of unspendable utxos with a new list. It’s important to note that the "must-be-spent" utxos added with
-//     /// TxBuilder.addUtxo have priority over these. See the Rust docs of the two linked methods for more details.
-//     pub(crate) fn unspendable(&self, unspendable: Vec<OutPoint>) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             unspendable: unspendable.into_iter().collect(),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Set a custom fee rate.
-//     pub(crate) fn fee_rate(&self, sat_per_vb: f32) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             fee_rate: Some(sat_per_vb),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Set an absolute fee.
-//     pub(crate) fn fee_absolute(&self, fee_amount: u64) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             fee_absolute: Some(fee_amount),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Spend all the available inputs. This respects filters like TxBuilder.unspendable and the change policy.
-//     pub(crate) fn drain_wallet(&self) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             drain_wallet: true,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Sets the address to drain excess coins to. Usually, when there are excess coins they are sent to a change address
-//     /// generated by the wallet. This option replaces the usual change address with an arbitrary ScriptPubKey of your choosing.
-//     /// Just as with a change output, if the drain output is not needed (the excess coins are too small) it will not be included
-//     /// in the resulting transaction. The only difference is that it is valid to use drain_to without setting any ordinary recipients
-//     /// with add_recipient (but it is perfectly fine to add recipients as well). If you choose not to set any recipients, you should
-//     /// either provide the utxos that the transaction should spend via add_utxos, or set drain_wallet to spend all of them.
-//     /// When bumping the fees of a transaction made with this option, you probably want to use BumpFeeTxBuilder.allow_shrinking
-//     /// to allow this output to be reduced to pay for the extra fees.
-//     pub(crate) fn drain_to(&self, script: Arc<Script>) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             drain_to: Some(script.inner.clone()),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Enable signaling RBF. This will use the default `nsequence` value of `0xFFFFFFFD`.
-//     pub(crate) fn enable_rbf(&self) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             rbf: Some(RbfValue::Default),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Enable signaling RBF with a specific nSequence value. This can cause conflicts if the wallet's descriptors contain an
-//     /// "older" (OP_CSV) operator and the given `nsequence` is lower than the CSV value. If the `nsequence` is higher than `0xFFFFFFFD`
-//     /// an error will be thrown, since it would not be a valid nSequence to signal RBF.
-//     pub(crate) fn enable_rbf_with_sequence(&self, nsequence: u32) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             rbf: Some(RbfValue::Value(nsequence)),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Add data as an output using OP_RETURN.
-//     pub(crate) fn add_data(&self, data: Vec<u8>) -> Arc<Self> {
-//         Arc::new(TxBuilder {
-//             data,
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Finish building the transaction. Returns the BIP174 PSBT.
-//     pub(crate) fn finish(&self, wallet: &Wallet) -> Result<TxBuilderResult, BdkError> {
-//         let wallet = wallet.get_wallet();
-//         let mut tx_builder = wallet.build_tx();
-//         for (script, amount) in &self.recipients {
-//             tx_builder.add_recipient(script.clone(), *amount);
-//         }
-//         tx_builder.change_policy(self.change_policy);
-//         if !self.utxos.is_empty() {
-//             let bdk_utxos: Vec<BdkOutPoint> = self.utxos.iter().map(BdkOutPoint::from).collect();
-//             let utxos: &[BdkOutPoint] = &bdk_utxos;
-//             tx_builder.add_utxos(utxos)?;
-//         }
-//         if !self.unspendable.is_empty() {
-//             let bdk_unspendable: Vec<BdkOutPoint> =
-//                 self.unspendable.iter().map(BdkOutPoint::from).collect();
-//             tx_builder.unspendable(bdk_unspendable);
-//         }
-//         if self.manually_selected_only {
-//             tx_builder.manually_selected_only();
-//         }
-//         if let Some(sat_per_vb) = self.fee_rate {
-//             tx_builder.fee_rate(FeeRate::from_sat_per_vb(sat_per_vb));
-//         }
-//         if let Some(fee_amount) = self.fee_absolute {
-//             tx_builder.fee_absolute(fee_amount);
-//         }
-//         if self.drain_wallet {
-//             tx_builder.drain_wallet();
-//         }
-//         if let Some(script) = &self.drain_to {
-//             tx_builder.drain_to(script.clone());
-//         }
-//         if let Some(rbf) = &self.rbf {
-//             match *rbf {
-//                 RbfValue::Default => {
-//                     tx_builder.enable_rbf();
-//                 }
-//                 RbfValue::Value(nsequence) => {
-//                     tx_builder.enable_rbf_with_sequence(Sequence(nsequence));
-//                 }
-//             }
-//         }
-//         if !&self.data.is_empty() {
-//             tx_builder.add_data(self.data.as_slice());
-//         }
-//
-//         tx_builder
-//             .finish()
-//             .map(|(psbt, tx_details)| TxBuilderResult {
-//                 psbt: Arc::new(PartiallySignedTransaction {
-//                     inner: Mutex::new(psbt),
-//                 }),
-//                 transaction_details: TransactionDetails::from(tx_details),
-//             })
-//     }
-// }
-//
-// /// The BumpFeeTxBuilder is used to bump the fee on a transaction that has been broadcast and has its RBF flag set to true.
-// #[derive(Clone)]
-// pub(crate) struct BumpFeeTxBuilder {
-//     pub(crate) txid: String,
-//     pub(crate) fee_rate: f32,
-//     pub(crate) allow_shrinking: Option<String>,
-//     pub(crate) rbf: Option<RbfValue>,
-// }
-//
-// impl BumpFeeTxBuilder {
-//     pub(crate) fn new(txid: String, fee_rate: f32) -> Self {
-//         Self {
-//             txid,
-//             fee_rate,
-//             allow_shrinking: None,
-//             rbf: None,
-//         }
-//     }
-//
-//     /// Explicitly tells the wallet that it is allowed to reduce the amount of the output matching this script_pubkey
-//     /// in order to bump the transaction fee. Without specifying this the wallet will attempt to find a change output to
-//     /// shrink instead. Note that the output may shrink to below the dust limit and therefore be removed. If it is preserved
-//     /// then it is currently not guaranteed to be in the same position as it was originally. Returns an error if script_pubkey
-//     /// can’t be found among the recipients of the transaction we are bumping.
-//     pub(crate) fn allow_shrinking(&self, address: String) -> Arc<Self> {
-//         Arc::new(Self {
-//             allow_shrinking: Some(address),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Enable signaling RBF. This will use the default `nsequence` value of `0xFFFFFFFD`.
-//     pub(crate) fn enable_rbf(&self) -> Arc<Self> {
-//         Arc::new(Self {
-//             rbf: Some(RbfValue::Default),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Enable signaling RBF with a specific nSequence value. This can cause conflicts if the wallet's descriptors contain an
-//     /// "older" (OP_CSV) operator and the given `nsequence` is lower than the CSV value. If the `nsequence` is higher than `0xFFFFFFFD`
-//     /// an error will be thrown, since it would not be a valid nSequence to signal RBF.
-//     pub(crate) fn enable_rbf_with_sequence(&self, nsequence: u32) -> Arc<Self> {
-//         Arc::new(Self {
-//             rbf: Some(RbfValue::Value(nsequence)),
-//             ..self.clone()
-//         })
-//     }
-//
-//     /// Finish building the transaction. Returns the BIP174 PSBT.
-//     pub(crate) fn finish(
-//         &self,
-//         wallet: &Wallet,
-//     ) -> Result<Arc<PartiallySignedTransaction>, BdkError> {
-//         let wallet = wallet.get_wallet();
-//         let txid = Txid::from_str(self.txid.as_str())?;
-//         let mut tx_builder = wallet.build_fee_bump(txid)?;
-//         tx_builder.fee_rate(FeeRate::from_sat_per_vb(self.fee_rate));
-//         if let Some(allow_shrinking) = &self.allow_shrinking {
-//             let address = BdkAddress::from_str(allow_shrinking)
-//                 .map_err(|e| BdkError::Generic(e.to_string()))?;
-//             let script = address.script_pubkey();
-//             tx_builder.allow_shrinking(script)?;
-//         }
-//         if let Some(rbf) = &self.rbf {
-//             match *rbf {
-//                 RbfValue::Default => {
-//                     tx_builder.enable_rbf();
-//                 }
-//                 RbfValue::Value(nsequence) => {
-//                     tx_builder.enable_rbf_with_sequence(Sequence(nsequence));
-//                 }
-//             }
-//         }
-//         tx_builder
-//             .finish()
-//             .map(|(psbt, _)| PartiallySignedTransaction {
-//                 inner: Mutex::new(psbt),
-//             })
-//             .map(Arc::new)
-//     }
-// }
-//
 // // The goal of these tests to to ensure `bdk-ffi` intermediate code correctly calls `bdk` APIs.
 // // These tests should not be used to verify `bdk` behavior that is already tested in the `bdk`
 // // crate.
@@ -860,10 +298,9 @@
 use crate::descriptor::Descriptor;
 use crate::Balance;
 use crate::{AddressIndex, AddressInfo, Network};
+use bdk::Error as BdkError;
 use bdk::Wallet as BdkWallet;
 use std::sync::{Arc, Mutex, MutexGuard};
-// use bdk::wallet::AddressIndex as BdkAddressIndex;
-use bdk::Error as BdkError;
 pub enum WalletType {
     Memory,
     FlatFile,