rust: read proxy and use it for ureq requests

Author: LeoComandini

subprojects/gdk_rust/gdk_electrum/src/error.rs

@@ -230,3 +230,9 @@ impl From<aead::Error> for Error {
         Error::Generic(err.to_string())
     }
 }
+
+impl From<ureq::Error> for Error {
+    fn from(err: ureq::Error) -> Self {
+        Error::Generic(err.to_string())
+    }
+}

subprojects/gdk_rust/gdk_electrum/src/lib.rs

@@ -112,6 +112,7 @@ impl Closer {
 
 pub struct ElectrumSession {
     pub data_root: String,
+    pub proxy: Option<String>,
     pub network: Network,
     pub url: ElectrumUrl,
     pub wallet: Option<Arc<RwLock<WalletCtx>>>,
@@ -179,16 +180,43 @@ pub fn determine_electrum_url_from_net(network: &Network) -> Result<ElectrumUrl,
     determine_electrum_url(&network.electrum_url, network.tls, network.validate_domain)
 }
 
+fn socksify(proxy: Option<&str>) -> Option<String> {
+    const SOCKS5: &str = "socks5://";
+    if let Some(proxy) = proxy {
+        let trimmed = proxy.trim();
+        if trimmed.is_empty() {
+            None
+        } else if trimmed.starts_with(SOCKS5) {
+            Some(trimmed.to_string())
+        } else {
+            Some(format!("{}{}", SOCKS5, trimmed))
+        }
+    } else {
+        None
+    }
+}
+
 impl ElectrumSession {
-    pub fn new_session(network: Network, db_root: &str, url: ElectrumUrl) -> Result<Self, Error> {
-        Ok(Self::create_session(network, db_root, url))
+    pub fn new_session(
+        network: Network,
+        db_root: &str,
+        proxy: Option<&str>,
+        url: ElectrumUrl,
+    ) -> Result<Self, Error> {
+        Ok(Self::create_session(network, db_root, proxy, url))
     }
 }
 
 impl ElectrumSession {
-    pub fn create_session(network: Network, db_root: &str, url: ElectrumUrl) -> Self {
+    pub fn create_session(
+        network: Network,
+        db_root: &str,
+        proxy: Option<&str>,
+        url: ElectrumUrl,
+    ) -> Self {
         Self {
             data_root: db_root.to_string(),
+            proxy: socksify(proxy),
             network,
             url,
             wallet: None,
@@ -213,8 +241,16 @@ impl ElectrumSession {
         Ok(wallet.write().unwrap())
     }
 
-    pub fn build_request_agent(&self) -> ureq::Agent {
-        ureq::Agent::new().build()
+    pub fn build_request_agent(&self) -> Result<ureq::Agent, Error> {
+        match &self.proxy {
+            Some(proxy) => {
+                let proxy = ureq::Proxy::new(&proxy)?;
+                let mut agent = ureq::agent();
+                agent.set_proxy(proxy);
+                Ok(agent)
+            }
+            None => Ok(ureq::agent()),
+        }
     }
 }
 
@@ -296,6 +332,11 @@ impl Session<Error> for ElectrumSession {
                 info!("setting db_root to {:?}", self.data_root);
             }
 
+            if self.proxy.is_none() {
+                self.proxy = socksify(net_params["proxy"].as_str());
+                info!("setting proxy to {:?}", self.proxy);
+            }
+
             let mnemonic = match self.get_mnemonic() {
                 Ok(mnemonic) => Some(mnemonic.clone()),
                 Err(_) => None,
@@ -323,7 +364,7 @@ impl Session<Error> for ElectrumSession {
         pin: String,
         details: PinGetDetails,
     ) -> Result<Vec<Notification>, Error> {
-        let agent = self.build_request_agent();
+        let agent = self.build_request_agent()?;
         let manager = PinManager::new(agent)?;
         let client_key = SecretKey::from_slice(&hex::decode(&details.pin_identifier)?)?;
         let server_key = manager.get_pin(pin.as_bytes(), &client_key)?;
@@ -627,7 +668,7 @@ impl Session<Error> for ElectrumSession {
     }
 
     fn set_pin(&self, details: &PinSetDetails) -> Result<PinGetDetails, Error> {
-        let agent = self.build_request_agent();
+        let agent = self.build_request_agent()?;
         let manager = PinManager::new(agent)?;
         let client_key = SecretKey::new(&mut thread_rng());
         let server_key = manager.set_pin(details.pin.as_bytes(), &client_key)?;
@@ -800,7 +841,7 @@ impl Session<Error> for ElectrumSession {
                 let last_modified =
                     self.get_wallet()?.store.read()?.cache.assets_last_modified.clone();
                 let base_url = self.network.registry_base_url()?;
-                let agent = self.build_request_agent();
+                let agent = self.build_request_agent()?;
                 thread::spawn(move || {
                     match call_assets(agent, base_url, registry_policy, last_modified) {
                         Ok(p) => tx_assets.send(Some(p)),
@@ -814,7 +855,7 @@ impl Session<Error> for ElectrumSession {
                 let last_modified =
                     self.get_wallet()?.store.read()?.cache.icons_last_modified.clone();
                 let base_url = self.network.registry_base_url()?;
-                let agent = self.build_request_agent();
+                let agent = self.build_request_agent()?;
                 thread::spawn(move || match call_icons(agent, base_url, last_modified) {
                     Ok(p) => tx_icons.send(Some(p)),
                     Err(_) => tx_icons.send(None),

subprojects/gdk_rust/src/lib.rs

@@ -201,15 +201,16 @@ fn create_session(network: &Value) -> Result<GdkSession, Value> {
     let parsed_network = parsed_network.unwrap();
 
     let db_root = network["db_root"].as_str().unwrap_or("");
+    let proxy = network["proxy"].as_str();
 
     match network["server_type"].as_str() {
         // Some("rpc") => GDKRUST_session::Rpc( GDKRPC_session::create_session(parsed_network.unwrap()).unwrap() ),
         Some("electrum") => {
             let url = gdk_electrum::determine_electrum_url_from_net(&parsed_network)
                 .map_err(|x| json!(x))?;
 
-            let session =
-                ElectrumSession::new_session(parsed_network, db_root, url).map_err(|x| json!(x))?;
+            let session = ElectrumSession::new_session(parsed_network, db_root, proxy, url)
+                .map_err(|x| json!(x))?;
             let backend = GdkBackend::Electrum(session);
 
             // some time in the past
@@ -235,12 +236,14 @@ fn fetch_cached_exchange_rates(sess: &mut GdkSession) -> Option<Vec<Ticker>> {
         let agent = match sess.backend {
             GdkBackend::Electrum(ref s) => s.build_request_agent(),
         };
-        let rates = fetch_exchange_rates(agent);
-        // still record time even if we get no results
-        sess.last_xr_fetch = SystemTime::now();
-        if !rates.is_empty() {
-            // only set last_xr if we got new non-empty rates
-            sess.last_xr = Some(rates);
+        if let Ok(agent) = agent {
+            let rates = fetch_exchange_rates(agent);
+            // still record time even if we get no results
+            sess.last_xr_fetch = SystemTime::now();
+            if !rates.is_empty() {
+                // only set last_xr if we got new non-empty rates
+                sess.last_xr = Some(rates);
+            }
         }
     }
 

subprojects/gdk_rust/tests/integration.rs

@@ -278,7 +278,8 @@ fn subaccounts() {
         let url = determine_electrum_url_from_net(&network).unwrap();
         let db_root_dir = TempDir::new("electrum_integration_tests").unwrap();
         let db_root = format!("{}", db_root_dir.path().display());
-        ElectrumSession::create_session(network, &db_root, url)
+        let proxy = Some("");
+        ElectrumSession::create_session(network, &db_root, proxy, url)
     };
     let mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about".to_string().into();
     new_session.login(&mnemonic, None).unwrap();

subprojects/gdk_rust/tests/test_session.rs

@@ -217,10 +217,11 @@ pub fn setup(
     let db_root_dir = TempDir::new("electrum_integration_tests").unwrap();
 
     let db_root = format!("{}", db_root_dir.path().display());
+    let proxy = Some("");
     let url = determine_electrum_url_from_net(&network).unwrap();
 
     info!("creating gdk session");
-    let mut session = ElectrumSession::create_session(network.clone(), &db_root, url);
+    let mut session = ElectrumSession::create_session(network.clone(), &db_root, proxy, url);
 
     let mnemonic: Mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about".to_string().into();
     info!("logging in gdk session");