feat(swap): cancel maker order for offline coins

mm2src/coins/lp_coins.rs

@@ -3884,6 +3884,27 @@ impl MmCoinEnum {
         self.ticker() == self.platform_ticker()
     }
 
+    /// Check if coin server connection is offline.
+    pub async fn is_offline(&self) -> bool {
+        match self {
+            MmCoinEnum::Bch(c) => c.as_ref().rpc_client.is_offline(),
+            MmCoinEnum::QtumCoin(c) => c.as_ref().rpc_client.is_offline(),
+            MmCoinEnum::Qrc20Coin(c) => c.as_ref().rpc_client.is_offline(),
+            MmCoinEnum::SlpToken(c) => c.as_ref().rpc_client.is_offline(),
+            MmCoinEnum::UtxoCoin(c) => c.as_ref().rpc_client.is_offline(),
+            MmCoinEnum::ZCoin(c) => c.as_ref().rpc_client.is_offline(),
+            MmCoinEnum::Tendermint(c) => c.get_live_client().await.is_err(),
+            MmCoinEnum::EthCoin(c) => c.current_block().compat().await.is_err(),
+            MmCoinEnum::TendermintToken(c) => c.platform_coin.get_live_client().await.is_err(),
+            #[cfg(feature = "enable-sia")]
+            MmCoinEnum::SiaCoin(c) => c.is_offline().await,
+            #[cfg(not(target_arch = "wasm32"))]
+            MmCoinEnum::LightningCoin(c) => c.platform_coin().as_ref().rpc_client.is_offline(),
+            #[cfg(any(test, feature = "for-tests"))]
+            MmCoinEnum::Test(_) => false,
+        }
+    }
+
     /// Determines the secret hash algorithm for a coin, prioritizing specific algorithms for certain protocols.
     /// # Attention
     /// When adding new coins, update this function to specify their appropriate secret hash algorithm.

mm2src/coins/siacoin.rs

@@ -35,6 +35,7 @@ pub mod sia_hd_wallet;
 
 #[derive(Clone)]
 pub struct SiaCoin(SiaArc);
+
 #[derive(Clone)]
 pub struct SiaArc(Arc<SiaCoinFields>);
 
@@ -233,6 +234,13 @@ impl SiaArc {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct SiaCoinProtocolInfo;
 
+impl SiaCoin {
+    /// Checks if `SiaCoin` api client is offline.
+    pub async fn is_offline(&self) -> bool {
+        self.0.http_client.current_height().await.is_err()
+    }
+}
+
 #[async_trait]
 impl MmCoin for SiaCoin {
     fn is_asset_chain(&self) -> bool {

mm2src/coins/tendermint/tendermint_coin.rs

@@ -90,7 +90,7 @@ use primitives::hash::H256;
 use regex::Regex;
 use rpc::v1::types::{Bytes as BytesJson, H264 as H264Json};
 use serde_json::{self as json, Value as Json};
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::io;
 use std::num::NonZeroU32;
@@ -365,7 +365,14 @@ impl TendermintActivationPolicy {
 struct TendermintRpcClient(AsyncMutex<TendermintRpcClientImpl>);
 
 struct TendermintRpcClientImpl {
-    rpc_clients: Vec<HttpClient>,
+    /// Using `VecDeque` instead of `Vec` for several performance reasons:
+    /// 1. O(1) operations for adding/removing clients at both ends (vs O(n) for `Vec.rotate_left()`)
+    /// 2. More efficient for the round-robin client selection pattern we use
+    /// 3. Better handling of client rotation without needing to clone the entire collection
+    ///
+    /// This approach improves performance in high-frequency scenarios where we need to
+    /// try multiple RPC nodes quickly to find a responsive one.
+    rpc_clients: VecDeque<HttpClient>,
 }
 
 #[async_trait]
@@ -375,22 +382,31 @@ impl RpcCommonOps for TendermintCoin {
 
     async fn get_live_client(&self) -> Result<Self::RpcClient, Self::Error> {
         let mut client_impl = self.client.0.lock().await;
+        let client_count = client_impl.rpc_clients.len();
+
         // try to find first live client
-        for (i, client) in client_impl.rpc_clients.clone().into_iter().enumerate() {
+        for _ in 0..client_count {
+            // SAFETY: Safe because we know the count and avoid bound check.
+            let client = client_impl.rpc_clients.pop_front().unwrap();
             match client.perform(HealthRequest).timeout(Duration::from_secs(15)).await {
                 Ok(Ok(_)) => {
                     // Bring the live client to the front of rpc_clients
-                    client_impl.rpc_clients.rotate_left(i);
+                    client_impl.rpc_clients.push_front(client.clone());
                     return Ok(client);
                 },
                 Ok(Err(rpc_error)) => {
                     debug!("Could not perform healthcheck on: {:?}. Error: {}", &client, rpc_error);
+                    // Put the failed client at the back of the queue
+                    client_impl.rpc_clients.push_back(client);
                 },
                 Err(timeout_error) => {
                     debug!("Healthcheck timeout exceed on: {:?}. Error: {}", &client, timeout_error);
+                    // Put the failed client at the back of the queue
+                    client_impl.rpc_clients.push_back(client);
                 },
             };
         }
+
         return Err(TendermintCoinRpcError::RpcClientError(
             "All the current rpc nodes are unavailable.".to_string(),
         ));
@@ -3204,7 +3220,7 @@ impl TendermintCoin {
     }
 }
 
-fn clients_from_urls(ctx: &MmArc, nodes: Vec<RpcNode>) -> MmResult<Vec<HttpClient>, TendermintInitErrorKind> {
+fn clients_from_urls(ctx: &MmArc, nodes: Vec<RpcNode>) -> MmResult<VecDeque<HttpClient>, TendermintInitErrorKind> {
     if nodes.is_empty() {
         return MmError::err(TendermintInitErrorKind::EmptyRpcUrls);
     }
@@ -3216,20 +3232,21 @@ fn clients_from_urls(ctx: &MmArc, nodes: Vec<RpcNode>) -> MmResult<Vec<HttpClien
         None
     };
 
-    let mut clients = Vec::new();
-    let mut errors = Vec::new();
+    let mut clients = VecDeque::with_capacity(nodes.len());
+    let mut errors = Vec::with_capacity(nodes.len());
 
     // check that all urls are valid
     // keep all invalid urls in one vector to show all of them in error
     for node in nodes.iter() {
         let proxy_sign_keypair = if node.komodo_proxy { p2p_keypair.clone() } else { None };
         match HttpClient::new(node.url.as_str(), proxy_sign_keypair) {
-            Ok(client) => clients.push(client),
+            Ok(client) => clients.push_back(client),
             Err(e) => errors.push(format!("Url {} is invalid, got error {}", node.url, e)),
         }
     }
     drop_mutability!(clients);
     drop_mutability!(errors);
+
     if !errors.is_empty() {
         let errors: String = errors.into_iter().join(", ");
         return MmError::err(TendermintInitErrorKind::RpcClientInitError(errors));

mm2src/coins/utxo/rpc_clients.rs

@@ -193,6 +193,15 @@ impl UtxoRpcClientEnum {
             UtxoRpcClientEnum::Electrum(_) => false,
         }
     }
+
+    /// Checks if all `ElectrumClient` servers are offline.
+    pub fn is_offline(&self) -> bool {
+        if let UtxoRpcClientEnum::Electrum(client) = self {
+            client.is_offline()
+        } else {
+            false
+        }
+    }
 }
 
 /// Generic unspent info required to build transactions, we need this separate type because native

mm2src/coins/utxo/rpc_clients/electrum_rpc/client.rs

@@ -837,6 +837,10 @@ impl ElectrumClient {
 
         Box::new(fut.boxed().compat())
     }
+
+    pub fn is_offline(&self) -> bool {
+        self.connection_manager.is_completely_offline()
+    }
 }
 
 // if mockable is placed before async_trait there is `munmap_chunk(): invalid pointer` error on async fn mocking attempt

mm2src/coins/utxo/rpc_clients/electrum_rpc/connection.rs

@@ -195,7 +195,7 @@ impl ElectrumConnection {
         self.abortable_system.weak_spawner()
     }
 
-    fn is_connected(&self) -> bool {
+    pub(crate) fn is_connected(&self) -> bool {
         self.tx.lock().unwrap().is_some()
     }
 

mm2src/coins/utxo/rpc_clients/electrum_rpc/connection_manager/manager.rs

@@ -317,6 +317,19 @@ impl ConnectionManager {
         self.write_connections().remove(server_address);
         Ok(connection)
     }
+
+    /// Checks if there are no live server connections available.
+    pub fn is_completely_offline(&self) -> bool {
+        for server_address in self.read_maintained_connections().values() {
+            if let Some(connection) = self.get_connection(server_address) {
+                if connection.is_connected() {
+                    return false;
+                }
+            };
+        }
+
+        true
+    }
 }
 
 // Background tasks.