From cdbf4242f620c9e31fda415be99c6b4bdd6e8cb4 Mon Sep 17 00:00:00 2001
From: rustaceanrob <rob.netzke@gmail.com>
Date: Tue, 6 Aug 2024 13:48:31 -0600
Subject: [PATCH] remove macros for in-memory connection

---
 bdk-ffi/src/bdk.udl   |  49 +-----
 bdk-ffi/src/lib.rs    |   1 -
 bdk-ffi/src/store.rs  |   5 +
 bdk-ffi/src/wallet.rs | 346 ++++++++++++++++++------------------------
 4 files changed, 154 insertions(+), 247 deletions(-)

diff --git a/bdk-ffi/src/bdk.udl b/bdk-ffi/src/bdk.udl
index 78315e7b..946bca89 100644
--- a/bdk-ffi/src/bdk.udl
+++ b/bdk-ffi/src/bdk.udl
@@ -431,46 +431,6 @@ interface Wallet {
   boolean persist(Connection connection);
 };
 
-interface WalletNoPersist {
-  [Throws=DescriptorError]
-  constructor(Descriptor descriptor, Descriptor change_descriptor, Network network);
-
-  AddressInfo reveal_next_address(KeychainKind keychain);
-
-  Network network();
-
-  Balance balance();
-
-  [Throws=CannotConnectError]
-  void apply_update(Update update);
-
-  boolean is_mine(Script script);
-
-  [Throws=SignerError]
-  boolean sign(Psbt psbt);
-
-  SentAndReceivedValues sent_and_received([ByRef] Transaction tx);
-
-  sequence<CanonicalTx> transactions();
-
-  [Throws=TxidParseError]
-  CanonicalTx? get_tx(string txid);
-
-  [Throws=CalculateFeeError]
-  Amount calculate_fee([ByRef] Transaction tx);
-
-  [Throws=CalculateFeeError]
-  FeeRate calculate_fee_rate([ByRef] Transaction tx);
-
-  sequence<LocalOutput> list_unspent();
-
-  sequence<LocalOutput> list_output();
-
-  FullScanRequest start_full_scan();
-
-  SyncRequest start_sync_with_revealed_spks();
-};
-
 interface Update {};
 
 interface TxBuilder {
@@ -508,9 +468,6 @@ interface TxBuilder {
 
   [Throws=CreateTxError]
   Psbt finish([ByRef] Wallet wallet);
-
-  [Throws=CreateTxError]
-  Psbt finish_no_persist([ByRef] WalletNoPersist wallet);
 };
 
 interface BumpFeeTxBuilder {
@@ -522,9 +479,6 @@ interface BumpFeeTxBuilder {
 
   [Throws=CreateTxError]
   Psbt finish([ByRef] Wallet wallet);
-
-  [Throws=CreateTxError]
-  Psbt finish_no_persist([ByRef] WalletNoPersist wallet);
 };
 
 // ------------------------------------------------------------------------
@@ -534,6 +488,9 @@ interface BumpFeeTxBuilder {
 interface Connection {
   [Throws=SqliteError]
   constructor(string path);
+  
+  [Name=new_in_memory, Throws=SqliteError]
+  constructor();
 };
 
 // ------------------------------------------------------------------------
diff --git a/bdk-ffi/src/lib.rs b/bdk-ffi/src/lib.rs
index 546e045f..321b7662 100644
--- a/bdk-ffi/src/lib.rs
+++ b/bdk-ffi/src/lib.rs
@@ -66,7 +66,6 @@ use crate::wallet::SentAndReceivedValues;
 use crate::types::SyncRequest;
 use crate::types::SyncScriptInspector;
 use crate::wallet::Wallet;
-use crate::wallet::WalletNoPersist;
 use crate::error::LoadWithPersistError;
 
 use bdk_wallet::bitcoin::Network;
diff --git a/bdk-ffi/src/store.rs b/bdk-ffi/src/store.rs
index 2ec25f6f..7ae2bb2b 100644
--- a/bdk-ffi/src/store.rs
+++ b/bdk-ffi/src/store.rs
@@ -13,6 +13,11 @@ impl Connection {
         Ok(Self(Mutex::new(connection)))
     }
 
+    pub fn new_in_memory() -> Result<Self, SqliteError> {
+        let connection = BdkConnection::open_in_memory()?;
+        Ok(Self(Mutex::new(connection)))
+    }
+
     pub(crate) fn get_store(&self) -> MutexGuard<BdkConnection> {
         self.0.lock().expect("must lock")
     }
diff --git a/bdk-ffi/src/wallet.rs b/bdk-ffi/src/wallet.rs
index b34a817b..5568a7b0 100644
--- a/bdk-ffi/src/wallet.rs
+++ b/bdk-ffi/src/wallet.rs
@@ -2,7 +2,7 @@ use crate::bitcoin::{Amount, FeeRate, OutPoint, Psbt, Script, Transaction};
 use crate::descriptor::Descriptor;
 use crate::error::{
     CalculateFeeError, CannotConnectError, CreateTxError, SignerError,
-    TxidParseError, CreateWithPersistError, DescriptorError, LoadWithPersistError,
+    TxidParseError, CreateWithPersistError, LoadWithPersistError,
 };
 use crate::store::Connection;
 use crate::types::{
@@ -31,10 +31,6 @@ pub struct Wallet {
     inner_mutex: Mutex<Persisted<BdkWallet>>,
 }
 
-pub struct WalletNoPersist {
-    inner_mutex: Mutex<BdkWallet>,
-}
-
 impl Wallet {
     pub fn new(
         descriptor: Arc<Descriptor>,
@@ -80,140 +76,109 @@ impl Wallet {
         self.inner_mutex.lock().expect("wallet")
     }
 
-    // pub fn persist(&self, connection: Connection) -> Result<bool, FfiGenericError> {
-    pub fn persist(&self, connection: Arc<Connection>) -> bool {
-        let mut binding = connection.get_store();
-        let db: &mut BdkConnection = binding.borrow_mut();
-        self.get_wallet().persist(db).expect("persist failed")
+    pub fn reveal_next_address(&self, keychain_kind: KeychainKind) -> AddressInfo {
+        self.get_wallet().reveal_next_address(keychain_kind).into()
     }
-}
-
-impl WalletNoPersist {
-    pub fn new(
-        descriptor: Arc<Descriptor>,
-        change_descriptor: Arc<Descriptor>,
-        network: Network,
-    ) -> Result<Self, DescriptorError> {
-        let descriptor = descriptor.to_string_with_secret();
-        let change_descriptor = change_descriptor.to_string_with_secret();
-
-        let wallet: BdkWallet = BdkWallet::create(descriptor, change_descriptor)
-            .network(network)
-            .create_wallet_no_persist()?;
 
-        Ok(WalletNoPersist {
-            inner_mutex: Mutex::new(wallet),
-        })
+    pub fn apply_update(&self, update: Arc<Update>) -> Result<(), CannotConnectError> {
+        self.get_wallet()
+            .apply_update(update.0.clone())
+            .map_err(CannotConnectError::from)
     }
 
-    pub(crate) fn get_wallet(&self) -> MutexGuard<BdkWallet> {
-        self.inner_mutex.lock().expect("wallet")
+    pub fn network(&self) -> Network {
+        self.get_wallet().network()
     }
-}
-
-macro_rules! impl_wallet {
-    ($w:ident) => {
-        impl $w {
-            pub fn reveal_next_address(&self, keychain_kind: KeychainKind) -> AddressInfo {
-                self.get_wallet().reveal_next_address(keychain_kind).into()
-            }
 
-            pub fn apply_update(&self, update: Arc<Update>) -> Result<(), CannotConnectError> {
-                self.get_wallet()
-                    .apply_update(update.0.clone())
-                    .map_err(CannotConnectError::from)
-            }
+    pub fn balance(&self) -> Balance {
+        let bdk_balance = self.get_wallet().balance();
+        Balance::from(bdk_balance)
+    }
 
-            pub fn network(&self) -> Network {
-                self.get_wallet().network()
-            }
+    pub fn is_mine(&self, script: Arc<Script>) -> bool {
+        self.get_wallet().is_mine(script.0.clone())
+    }
 
-            pub fn balance(&self) -> Balance {
-                let bdk_balance = self.get_wallet().balance();
-                Balance::from(bdk_balance)
-            }
+    pub(crate) fn sign(
+        &self,
+        psbt: Arc<Psbt>,
+        // sign_options: Option<SignOptions>,
+    ) -> Result<bool, SignerError> {
+        let mut psbt = psbt.0.lock().unwrap();
+        self.get_wallet()
+            .sign(&mut psbt, SignOptions::default())
+            .map_err(SignerError::from)
+    }
 
-            pub fn is_mine(&self, script: Arc<Script>) -> bool {
-                self.get_wallet().is_mine(script.0.clone())
-            }
+    pub fn sent_and_received(&self, tx: &Transaction) -> SentAndReceivedValues {
+        let (sent, received) = self.get_wallet().sent_and_received(&tx.into());
+        SentAndReceivedValues {
+            sent: Arc::new(sent.into()),
+            received: Arc::new(received.into()),
+        }
+    }
 
-            pub(crate) fn sign(
-                &self,
-                psbt: Arc<Psbt>,
-                // sign_options: Option<SignOptions>,
-            ) -> Result<bool, SignerError> {
-                let mut psbt = psbt.0.lock().unwrap();
-                self.get_wallet()
-                    .sign(&mut psbt, SignOptions::default())
-                    .map_err(SignerError::from)
-            }
+    pub fn transactions(&self) -> Vec<CanonicalTx> {
+        self.get_wallet()
+            .transactions()
+            .map(|tx| tx.into())
+            .collect()
+    }
 
-            pub fn sent_and_received(&self, tx: &Transaction) -> SentAndReceivedValues {
-                let (sent, received) = self.get_wallet().sent_and_received(&tx.into());
-                SentAndReceivedValues {
-                    sent: Arc::new(sent.into()),
-                    received: Arc::new(received.into()),
-                }
-            }
+    pub fn get_tx(&self, txid: String) -> Result<Option<CanonicalTx>, TxidParseError> {
+        let txid = Txid::from_str(txid.as_str())
+            .map_err(|_| TxidParseError::InvalidTxid { txid })?;
+        Ok(self.get_wallet().get_tx(txid).map(|tx| tx.into()))
+    }
 
-            pub fn transactions(&self) -> Vec<CanonicalTx> {
-                self.get_wallet()
-                    .transactions()
-                    .map(|tx| tx.into())
-                    .collect()
-            }
+    pub fn calculate_fee(
+        &self,
+        tx: &Transaction,
+    ) -> Result<Arc<Amount>, CalculateFeeError> {
+        self.get_wallet()
+            .calculate_fee(&tx.into())
+            .map(Amount::from)
+            .map(Arc::new)
+            .map_err(|e| e.into())
+    }
 
-            pub fn get_tx(&self, txid: String) -> Result<Option<CanonicalTx>, TxidParseError> {
-                let txid = Txid::from_str(txid.as_str())
-                    .map_err(|_| TxidParseError::InvalidTxid { txid })?;
-                Ok(self.get_wallet().get_tx(txid).map(|tx| tx.into()))
-            }
+    pub fn calculate_fee_rate(
+        &self,
+        tx: &Transaction,
+    ) -> Result<Arc<FeeRate>, CalculateFeeError> {
+        self.get_wallet()
+            .calculate_fee_rate(&tx.into())
+            .map(|bdk_fee_rate| Arc::new(FeeRate(bdk_fee_rate)))
+            .map_err(|e| e.into())
+    }
 
-            pub fn calculate_fee(
-                &self,
-                tx: &Transaction,
-            ) -> Result<Arc<Amount>, CalculateFeeError> {
-                self.get_wallet()
-                    .calculate_fee(&tx.into())
-                    .map(Amount::from)
-                    .map(Arc::new)
-                    .map_err(|e| e.into())
-            }
+    pub fn list_unspent(&self) -> Vec<LocalOutput> {
+        self.get_wallet().list_unspent().map(|o| o.into()).collect()
+    }
 
-            pub fn calculate_fee_rate(
-                &self,
-                tx: &Transaction,
-            ) -> Result<Arc<FeeRate>, CalculateFeeError> {
-                self.get_wallet()
-                    .calculate_fee_rate(&tx.into())
-                    .map(|bdk_fee_rate| Arc::new(FeeRate(bdk_fee_rate)))
-                    .map_err(|e| e.into())
-            }
+    pub fn list_output(&self) -> Vec<LocalOutput> {
+        self.get_wallet().list_output().map(|o| o.into()).collect()
+    }
 
-            pub fn list_unspent(&self) -> Vec<LocalOutput> {
-                self.get_wallet().list_unspent().map(|o| o.into()).collect()
-            }
+    pub fn start_full_scan(&self) -> Arc<FullScanRequest> {
+        let request = self.get_wallet().start_full_scan();
+        Arc::new(FullScanRequest(Mutex::new(Some(request))))
+    }
 
-            pub fn list_output(&self) -> Vec<LocalOutput> {
-                self.get_wallet().list_output().map(|o| o.into()).collect()
-            }
+    pub fn start_sync_with_revealed_spks(&self) -> Arc<SyncRequest> {
+        let request = self.get_wallet().start_sync_with_revealed_spks();
+        Arc::new(SyncRequest(Mutex::new(Some(request))))
+    }
 
-            pub fn start_full_scan(&self) -> Arc<FullScanRequest> {
-                let request = self.get_wallet().start_full_scan();
-                Arc::new(FullScanRequest(Mutex::new(Some(request))))
-            }
+    // pub fn persist(&self, connection: Connection) -> Result<bool, FfiGenericError> {
+    pub fn persist(&self, connection: Arc<Connection>) -> bool {
+        let mut binding = connection.get_store();
+        let db: &mut BdkConnection = binding.borrow_mut();
+        self.get_wallet().persist(db).expect("persist failed")
+    }
 
-            pub fn start_sync_with_revealed_spks(&self) -> Arc<SyncRequest> {
-                let request = self.get_wallet().start_sync_with_revealed_spks();
-                Arc::new(SyncRequest(Mutex::new(Some(request))))
-            }
-        }
-    };
 }
 
-impl_wallet!(Wallet);
-impl_wallet!(WalletNoPersist);
-
 pub struct SentAndReceivedValues {
     pub sent: Arc<Amount>,
     pub received: Arc<Amount>,
@@ -370,66 +335,57 @@ impl TxBuilder {
             ..self.clone()
         })
     }
-}
 
-macro_rules! impl_tx_finish {
-    ($tx_builder:ident, $wallet:ident, $func_name:ident) => {
-        impl $tx_builder {
-            pub(crate) fn $func_name(&self, wallet: &Arc<$wallet>) -> Result<Arc<Psbt>, CreateTxError> {
-                // TODO: I had to change the wallet here to be mutable. Why is that now required with the 1.0 API?
-                let mut 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();
-                    tx_builder
-                        .add_utxos(&bdk_utxos)
-                        .map_err(CreateTxError::from)?;
-                }
-                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(fee_rate) = &self.fee_rate {
-                    tx_builder.fee_rate(fee_rate.0);
-                }
-                if let Some(fee_amount) = &self.fee_absolute {
-                    tx_builder.fee_absolute(fee_amount.0);
-                }
-                if self.drain_wallet {
-                    tx_builder.drain_wallet();
-                }
-                if let Some(script) = &self.drain_to {
-                    tx_builder.drain_to(script.clone());
+    pub(crate) fn finish(&self, wallet: &Arc<Wallet>) -> Result<Arc<Psbt>, CreateTxError> {
+        // TODO: I had to change the wallet here to be mutable. Why is that now required with the 1.0 API?
+        let mut 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();
+            tx_builder
+                .add_utxos(&bdk_utxos)
+                .map_err(CreateTxError::from)?;
+        }
+        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(fee_rate) = &self.fee_rate {
+            tx_builder.fee_rate(fee_rate.0);
+        }
+        if let Some(fee_amount) = &self.fee_absolute {
+            tx_builder.fee_absolute(fee_amount.0);
+        }
+        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();
                 }
-                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));
-                        }
-                    }
+                RbfValue::Value(nsequence) => {
+                    tx_builder.enable_rbf_with_sequence(Sequence(nsequence));
                 }
-
-                let psbt = tx_builder.finish().map_err(CreateTxError::from)?;
-
-                Ok(Arc::new(psbt.into()))
             }
         }
-    };
-}
 
-impl_tx_finish!(TxBuilder, Wallet, finish);
-impl_tx_finish!(TxBuilder, WalletNoPersist, finish_no_persist);
+        let psbt = tx_builder.finish().map_err(CreateTxError::from)?;
+
+        Ok(Arc::new(psbt.into()))
+    }
+}
 
 #[derive(Clone)]
 pub(crate) struct BumpFeeTxBuilder {
@@ -460,39 +416,29 @@ impl BumpFeeTxBuilder {
             ..self.clone()
         })
     }
-}
 
-macro_rules! impl_tx_bump {
-    ($tx_bumper:ident, $wallet:ident, $func_name:ident) => {
-        impl $tx_bumper {
-            pub(crate) fn $func_name(&self, wallet: &$wallet) -> Result<Arc<Psbt>, CreateTxError> {
-                let txid = Txid::from_str(self.txid.as_str()).map_err(|_| CreateTxError::UnknownUtxo {
-                    outpoint: self.txid.clone(),
-                })?;
-                let mut wallet = wallet.get_wallet();
-                let mut tx_builder = wallet.build_fee_bump(txid).map_err(CreateTxError::from)?;
-                tx_builder.fee_rate(self.fee_rate.0);
-                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));
-                        }
-                    }
+    pub(crate) fn finish(&self, wallet: &Arc<Wallet>) -> Result<Arc<Psbt>, CreateTxError> {
+        let txid = Txid::from_str(self.txid.as_str()).map_err(|_| CreateTxError::UnknownUtxo {
+            outpoint: self.txid.clone(),
+        })?;
+        let mut wallet = wallet.get_wallet();
+        let mut tx_builder = wallet.build_fee_bump(txid).map_err(CreateTxError::from)?;
+        tx_builder.fee_rate(self.fee_rate.0);
+        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));
                 }
-                let psbt: BdkPsbt = tx_builder.finish()?;
-
-                Ok(Arc::new(psbt.into()))
             }
         }
-    };
-}
-
-impl_tx_bump!(BumpFeeTxBuilder, Wallet, finish);
-impl_tx_bump!(BumpFeeTxBuilder, WalletNoPersist, finish_no_persist);
+        let psbt: BdkPsbt = tx_builder.finish()?;
 
+        Ok(Arc::new(psbt.into()))
+    }
+}
 #[derive(Clone, Debug)]
 pub enum RbfValue {
     Default,