detect and act on network change

libs/Cargo.toml

@@ -43,7 +43,7 @@ serde_json = "1.0"
 strum = "0.25"
 strum_macros = "0.25"
 thiserror = "1.0.56"
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1.41", features = ["full"] }
 tonic = "^0.8"
 tonic-build = "^0.8"
 uniffi = "0.23.0"

libs/sdk-common/src/breez_server.rs

@@ -16,6 +16,7 @@ use crate::grpc::support_client::SupportClient;
 use crate::grpc::swapper_client::SwapperClient;
 use crate::grpc::{ChainApiServersRequest, PingRequest};
 use crate::prelude::{ServiceConnectivityError, ServiceConnectivityErrorKind};
+use crate::tonic_wrap::with_connection_fallback;
 
 pub static PRODUCTION_BREEZSERVER_URL: &str = "https://bs1.breez.technology:443";
 pub static STAGING_BREEZSERVER_URL: &str = "https://bs1-st.breez.technology:443";
@@ -112,9 +113,11 @@ impl BreezServer {
 
     pub async fn fetch_mempoolspace_urls(&self) -> Result<Vec<String>, ServiceConnectivityError> {
         let mut client = self.get_information_client().await;
-
-        let chain_api_servers = client
-            .chain_api_servers(ChainApiServersRequest {})
+        let mut client_clone = client.clone();
+        let chain_api_servers =
+            with_connection_fallback(client.chain_api_servers(ChainApiServersRequest {}), || {
+                client_clone.chain_api_servers(ChainApiServersRequest {})
+            })
             .await
             .map_err(|e| {
                 ServiceConnectivityError::new(
@@ -138,9 +141,12 @@ impl BreezServer {
 
     pub async fn fetch_boltz_swapper_urls(&self) -> Result<Vec<String>, ServiceConnectivityError> {
         let mut client = self.get_information_client().await;
+        let mut client_clone = client.clone();
 
-        let chain_api_servers = client
-            .chain_api_servers(ChainApiServersRequest {})
+        let chain_api_servers =
+            with_connection_fallback(client.chain_api_servers(ChainApiServersRequest {}), || {
+                client_clone.chain_api_servers(ChainApiServersRequest {})
+            })
             .await
             .map_err(|e| {
                 ServiceConnectivityError::new(
@@ -163,6 +169,7 @@ impl BreezServer {
     }
 }
 
+#[derive(Clone)]
 pub struct ApiKeyInterceptor {
     api_key_metadata: Option<MetadataValue<Ascii>>,
 }

libs/sdk-common/src/fiat.rs

@@ -2,10 +2,10 @@ use std::collections::HashMap;
 
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
-use tonic::Request;
 
 use crate::grpc::RatesRequest;
 use crate::prelude::BreezServer;
+use crate::tonic_wrap::with_connection_fallback;
 
 /// Trait covering fiat-related functionality
 #[tonic::async_trait]
@@ -97,12 +97,14 @@ impl FiatAPI for BreezServer {
 
     async fn fetch_fiat_rates(&self) -> Result<Vec<Rate>> {
         let mut client = self.get_information_client().await;
-
-        let request = Request::new(RatesRequest {});
-        let response = client
-            .rates(request)
-            .await
-            .map_err(|e| anyhow!("Fetch rates request failed: {e}"))?;
+        let mut client_clone = client.clone();
+
+        let request = RatesRequest {};
+        let response = with_connection_fallback(client.rates(request.clone()), || {
+            client_clone.rates(request)
+        })
+        .await
+        .map_err(|e| anyhow!("Fetch rates request failed: {e}"))?;
 
         let mut rates = response.into_inner().rates;
         rates.sort_by(|a, b| a.coin.cmp(&b.coin));

libs/sdk-common/src/lib.rs

@@ -9,6 +9,7 @@ pub mod invoice;
 pub mod liquid;
 mod lnurl;
 mod model;
+pub mod tonic_wrap;
 mod utils;
 
 // Re-export commonly used crates, to make it easy for callers to use the specific versions we're using.

libs/sdk-common/src/tonic_wrap/mod.rs

@@ -0,0 +1,82 @@
+use std::{error::Error, fmt::Display, future::Future};
+
+use log::debug;
+
+pub struct Status(pub tonic::Status);
+
+impl Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "status: {:?}, message: {:?}, details: {:?}, metadata: {:?}, source: {:?}",
+            self.0.code(),
+            self.0.message(),
+            self.0.details(),
+            self.0.metadata(),
+            self.0.source(),
+        )
+    }
+}
+
+pub struct TransportError(pub tonic::transport::Error);
+
+impl Display for TransportError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "description: {:?}, source: {:?}",
+            self.0.to_string(),
+            self.0.source(),
+        )
+    }
+}
+
+pub async fn with_connection_fallback<T, M, F>(
+    main: M,
+    fallback: impl FnOnce() -> F,
+) -> Result<T, tonic::Status>
+where
+    M: Future<Output = Result<T, tonic::Status>>,
+    F: Future<Output = Result<T, tonic::Status>>,
+    T: std::fmt::Debug,
+{
+    let res = main.await;
+    let status = match res {
+        Ok(t) => return Ok(t),
+        Err(s) => s,
+    };
+
+    debug!(
+        "with_connection_fallback: initial call failed with: {:?}",
+        status
+    );
+    let source = match status.source() {
+        Some(source) => source,
+        None => return Err(status),
+    };
+
+    let error: &tonic::transport::Error = match source.downcast_ref() {
+        Some(error) => error,
+        None => return Err(status),
+    };
+
+    if error.to_string() != "transport error" {
+        return Err(status);
+    }
+
+    let source = match error.source() {
+        Some(source) => source,
+        None => return Err(status),
+    };
+
+    if !source.to_string().contains("keep-alive timed out") {
+        return Err(status);
+    }
+
+    debug!(
+        "with_connection_fallback: initial call failed due to keepalive 
+        timeout. Retrying fallback."
+    );
+
+    fallback().await
+}