rust: use proxy for electrum requests

Author: LeoComandini

subprojects/gdk_rust/gdk_electrum/src/account.rs

@@ -674,12 +674,13 @@ pub fn discover_accounts(
     master_xprv: &ExtendedPrivKey,
     network_id: NetworkId,
     electrum_url: &ElectrumUrl,
+    proxy: Option<&str>,
     master_blinding: Option<&MasterBlindingKey>,
 ) -> Result<Vec<u32>, Error> {
     use electrum_client::ElectrumApi;
 
     // build our own client so that the subscriptions are dropped at the end
-    let client = electrum_url.build_client()?;
+    let client = electrum_url.build_client(proxy)?;
 
     // the batch size is the effective gap limit for our purposes. in reality it is a lower bound.
     let gap_limit = BATCH_SIZE;

subprojects/gdk_rust/gdk_electrum/src/headers/mod.rs

@@ -73,7 +73,7 @@ pub fn spv_verify_tx(input: &SPVVerifyTx) -> Result<SPVVerifyResult, Error> {
     }
 
     let url = determine_electrum_url_from_net(&input.network)?;
-    let client = url.build_client()?;
+    let client = url.build_client(input.tor_proxy.as_deref())?;
 
     match input.network.id() {
         NetworkId::Bitcoin(bitcoin_network) => {

subprojects/gdk_rust/gdk_electrum/src/interface.rs

@@ -42,8 +42,13 @@ pub enum ElectrumUrl {
 }
 
 impl ElectrumUrl {
-    pub fn build_client(&self) -> Result<Client, Error> {
-        self.build_config(ConfigBuilder::new())
+    pub fn build_client(&self, proxy: Option<&str>) -> Result<Client, Error> {
+        let mut config = ConfigBuilder::new();
+        if let Some(proxy) = proxy {
+            // TODO: add support for credentials?
+            config = config.socks5(Some(electrum_client::Socks5Config::new(proxy)))?;
+        }
+        self.build_config(config)
     }
 
     pub fn build_config(&self, config: ConfigBuilder) -> Result<Client, Error> {
@@ -163,11 +168,16 @@ impl WalletCtx {
         self.get_account(opt.subaccount)?.set_settings(opt)
     }
 
-    pub fn recover_accounts(&mut self, electrum_url: &ElectrumUrl) -> Result<(), Error> {
+    pub fn recover_accounts(
+        &mut self,
+        electrum_url: &ElectrumUrl,
+        proxy: Option<&str>,
+    ) -> Result<(), Error> {
         let account_nums = discover_accounts(
             &self.master_xprv,
             self.network.id(),
             electrum_url,
+            proxy,
             self.master_blinding.as_ref(),
         )?;
         for account_num in account_nums {

subprojects/gdk_rust/gdk_electrum/src/lib.rs

@@ -455,7 +455,7 @@ impl Session<Error> for ElectrumSession {
         notify_block(self.notify.clone(), tip_height);
 
         info!("building client");
-        if let Ok(fee_client) = self.url.build_client() {
+        if let Ok(fee_client) = self.url.build_client(self.proxy.as_deref()) {
             info!("building built end");
             let fee_store = store.clone();
             thread::spawn(move || {
@@ -492,6 +492,7 @@ impl Session<Error> for ElectrumSession {
             };
 
             let headers_url = self.url.clone();
+            let proxy = self.proxy.clone();
             let (close_headers, r) = channel();
             self.closer.senders.push(close_headers);
             let notify_headers = self.notify.clone();
@@ -506,7 +507,7 @@ impl Session<Error> for ElectrumSession {
                         break;
                     }
 
-                    if let Ok(client) = headers_url.build_client() {
+                    if let Ok(client) = headers_url.build_client(proxy.as_deref()) {
                         loop {
                             if r.try_recv().is_ok() {
                                 info!("closing headers thread");
@@ -579,7 +580,7 @@ impl Session<Error> for ElectrumSession {
 
         // Recover BIP 44 accounts on the first login
         if !store.read().unwrap().cache.accounts_recovered {
-            wallet.write().unwrap().recover_accounts(&self.url)?;
+            wallet.write().unwrap().recover_accounts(&self.url, self.proxy.as_deref())?;
             store.write().unwrap().cache.accounts_recovered = true;
         }
 
@@ -602,10 +603,11 @@ impl Session<Error> for ElectrumSession {
         let (close_tipper, r) = channel();
         self.closer.senders.push(close_tipper);
         let tipper_url = self.url.clone();
+        let proxy = self.proxy.clone();
         let tipper_handle = thread::spawn(move || {
             info!("starting tipper thread");
             loop {
-                if let Ok(client) = tipper_url.build_client() {
+                if let Ok(client) = tipper_url.build_client(proxy.as_deref()) {
                     match tipper.tip(&client) {
                         Ok(current_tip) => {
                             if tip_height != current_tip {
@@ -631,10 +633,11 @@ impl Session<Error> for ElectrumSession {
         self.closer.senders.push(close_syncer);
         let notify_txs = self.notify.clone();
         let syncer_url = self.url.clone();
+        let proxy = self.proxy.clone();
         let syncer_handle = thread::spawn(move || {
             info!("starting syncer thread");
             loop {
-                match syncer_url.build_client() {
+                match syncer_url.build_client(proxy.as_deref()) {
                     Ok(client) => match syncer.sync(&client) {
                         Ok(updated_accounts) => {
                             for account_num in updated_accounts {
@@ -764,7 +767,7 @@ impl Session<Error> for ElectrumSession {
 
     fn send_transaction(&mut self, tx: &TransactionMeta) -> Result<String, Error> {
         info!("electrum send_transaction {:#?}", tx);
-        let client = self.url.build_client()?;
+        let client = self.url.build_client(self.proxy.as_deref())?;
         let tx_bytes = hex::decode(&tx.hex)?;
         let txid = client.transaction_broadcast_raw(&tx_bytes)?;
         Ok(format!("{}", txid))
@@ -774,7 +777,7 @@ impl Session<Error> for ElectrumSession {
         let transaction = BETransaction::from_hex(&tx_hex, self.network.id())?;
 
         info!("broadcast_transaction {:#?}", transaction.txid());
-        let client = self.url.build_client()?;
+        let client = self.url.build_client(self.proxy.as_deref())?;
         let hex = hex::decode(tx_hex)?;
         let txid = client.transaction_broadcast_raw(&hex)?;
         Ok(format!("{}", txid))
@@ -790,7 +793,7 @@ impl Session<Error> for ElectrumSession {
             NetworkId::Bitcoin(_) => 1000,
             NetworkId::Elements(_) => 100,
         };
-        let fee_estimates = try_get_fee_estimates(&self.url.build_client()?)
+        let fee_estimates = try_get_fee_estimates(&self.url.build_client(self.proxy.as_deref())?)
             .unwrap_or_else(|_| vec![FeeEstimate(min_fee); 25]);
         self.get_wallet()?.store.write()?.cache.fee_estimates = fee_estimates.clone();
         Ok(fee_estimates)