feat: implement fallback rpcs

.github/README.md

@@ -73,8 +73,8 @@ cargo uninstall book-of-profits
 | `✅`                      | Show global balance                                                                  |
 | `✅`                      | Export raw configuration in plaintext                                                |
 | `✅`                      | Display spinner when loading                                                         |
+| `✅`                      | Fallback RPCs                                                                        |
 | `⚠️` Not supported in EVM | Scan for token holdings in account and automatically add them                        |
-| `❌`                      | Fallback RPCs                                                                        |
 | `❌`                      | Show balance by chain                                                                |
 | `❌`                      | Show balance by account                                                              |
 | `❌`                      | Automatically prune low liquidity tokens                                             |

src/chain/chain_properties.rs

@@ -4,7 +4,7 @@ use std::fmt::Display;
 
 #[derive(Debug, Clone)]
 pub struct ChainProperties {
-    pub rpc_url: Url,
+    pub rpc_urls: Vec<Url>,
     pub rpc_headers: HeaderMap,
     pub name: String,
     pub native_token: Token,

src/chain/evm_chain.rs

@@ -27,7 +27,12 @@ impl From<&Chain> for EvmChain {
 }
 
 impl EvmChain {
-    async fn rpc_call(&self, method: &str, params: Value) -> (Option<String>, Option<f32>) {
+    async fn rpc_call(
+        &self,
+        method: &str,
+        params: Value,
+        rpc_index: usize,
+    ) -> (Option<String>, Option<f32>) {
         let payload = json!({
             "jsonrpc": "2.0",
             "id": "1",
@@ -36,7 +41,7 @@ impl EvmChain {
         });
         let response = match self
             .http_client
-            .post(self.properties.rpc_url.clone())
+            .post(self.properties.rpc_urls[rpc_index % self.properties.rpc_urls.len()].clone())
             .json(&payload)
             .send()
             .await
@@ -58,9 +63,13 @@ impl EvmChain {
 }
 
 impl ChainOps for EvmChain {
-    async fn get_native_token_balance(&self, address: &str) -> (Option<BigUint>, Option<f32>) {
+    async fn get_native_token_balance(
+        &self,
+        address: &str,
+        rpc_index: usize,
+    ) -> (Option<BigUint>, Option<f32>) {
         let (balance_hex, wait_time) = self
-            .rpc_call("eth_getBalance", json!([address, "latest"]))
+            .rpc_call("eth_getBalance", json!([address, "latest"]), rpc_index)
             .await;
         (
             balance_hex.and_then(|b| BigUint::parse_bytes(&b.as_bytes()[2..], 16)),
@@ -71,6 +80,7 @@ impl ChainOps for EvmChain {
         &self,
         token: &Token,
         address: &str,
+        rpc_index: usize,
     ) -> (Option<BigUint>, Option<f32>) {
         let params = json!([
             {
@@ -79,29 +89,37 @@ impl ChainOps for EvmChain {
             },
             "latest"
         ]);
-        let (balance_hex, wait_time) = self.rpc_call("eth_call", params).await;
+        let (balance_hex, wait_time) = self.rpc_call("eth_call", params, rpc_index).await;
         (
             balance_hex.and_then(|b| BigUint::parse_bytes(&b.as_bytes()[2..], 16)),
             wait_time,
         )
     }
-    async fn get_holdings_balance(&self, _address: &str) -> SupportOption<Vec<(String, BigUint)>> {
+    async fn get_holdings_balance(
+        &self,
+        _address: &str,
+        _rpc_index: usize,
+    ) -> SupportOption<Vec<(String, BigUint)>> {
         SupportOption::Unsupported
     }
-    async fn get_token_decimals(&self, token_address: &str) -> Option<usize> {
+    async fn get_token_decimals(&self, token_address: &str, rpc_index: usize) -> Option<usize> {
         let params = json!([
             {
                 "to": token_address,
                 "data": "0x313ce567",
             },
             "latest"
         ]);
-        let decimals_hex = self.rpc_call("eth_call", params).await.0?;
+        let decimals_hex = self.rpc_call("eth_call", params, rpc_index).await.0?;
         BigUint::parse_bytes(&decimals_hex.as_bytes()[2..], 16)?
             .to_usize()
             .into()
     }
-    async fn scan_for_tokens(&self, _address: &str) -> SupportOption<Vec<Token>> {
+    async fn scan_for_tokens(
+        &self,
+        _address: &str,
+        _rpc_index: usize,
+    ) -> SupportOption<Vec<Token>> {
         SupportOption::Unsupported
     }
     fn parse_wallet_address(&self, address: &str) -> Option<String> {

src/chain/mod.rs

@@ -28,14 +28,14 @@ pub struct Chain {
 impl Chain {
     pub fn new(
         chain_type: ChainType,
-        rpc_url: &str,
+        rpc_urls: Vec<&str>,
         name: &str,
         native_token_symbol: &str,
         native_token_address: &str,
         native_token_decimals: usize,
     ) -> Self {
         let properties = ChainProperties {
-            rpc_url: Url::from_str(rpc_url).unwrap(),
+            rpc_urls: rpc_urls.iter().map(|u| Url::from_str(u).unwrap()).collect(),
             rpc_headers: HeaderMap::new(),
             name: name.to_string(),
             native_token: Token::hardcode(
@@ -53,19 +53,28 @@ impl Chain {
 }
 
 pub trait ChainOps {
-    async fn get_native_token_balance(&self, address: &str) -> (Option<BigUint>, Option<f32>);
+    async fn get_native_token_balance(
+        &self,
+        address: &str,
+        rpc_index: usize,
+    ) -> (Option<BigUint>, Option<f32>);
     async fn get_token_balance(
         &self,
         token: &Token,
         address: &str,
+        rpc_index: usize,
     ) -> (Option<BigUint>, Option<f32>);
-    async fn get_token_decimals(&self, token_address: &str) -> Option<usize>;
-    async fn get_token_symbol(&self, token_address: &str) -> Option<String> {
+    async fn get_token_decimals(&self, token_address: &str, rpc_index: usize) -> Option<usize>;
+    async fn get_token_symbol(&self, token_address: &str, _rpc_index: usize) -> Option<String> {
         let pairs = dexscreener::pairs::get_pairs(vec![token_address]).await?;
         (pairs.len() != 0).then(|| pairs[0].base_token.symbol.clone())
     }
-    async fn get_holdings_balance(&self, address: &str) -> SupportOption<Vec<(String, BigUint)>>;
-    async fn scan_for_tokens(&self, address: &str) -> SupportOption<Vec<Token>>;
+    async fn get_holdings_balance(
+        &self,
+        address: &str,
+        rpc_index: usize,
+    ) -> SupportOption<Vec<(String, BigUint)>>;
+    async fn scan_for_tokens(&self, address: &str, rpc_index: usize) -> SupportOption<Vec<Token>>;
     fn parse_wallet_address(&self, address: &str) -> Option<String>;
     fn parse_token_address(&self, address: &str) -> Option<String> {
         self.parse_wallet_address(address)
@@ -90,27 +99,36 @@ macro_rules! chain_ops_method {
 }
 
 impl ChainOps for Chain {
-    async fn get_native_token_balance(&self, address: &str) -> (Option<BigUint>, Option<f32>) {
-        chain_ops_method!(self, get_native_token_balance, address; await)
+    async fn get_native_token_balance(
+        &self,
+        address: &str,
+        rpc_index: usize,
+    ) -> (Option<BigUint>, Option<f32>) {
+        chain_ops_method!(self, get_native_token_balance, address, rpc_index; await)
     }
     async fn get_token_balance(
         &self,
         token: &Token,
         address: &str,
+        rpc_index: usize,
     ) -> (Option<BigUint>, Option<f32>) {
-        chain_ops_method!(self, get_token_balance, token, address; await)
+        chain_ops_method!(self, get_token_balance, token, address, rpc_index; await)
     }
-    async fn get_holdings_balance(&self, address: &str) -> SupportOption<Vec<(String, BigUint)>> {
-        chain_ops_method!(self, get_holdings_balance, address; await)
+    async fn get_holdings_balance(
+        &self,
+        address: &str,
+        rpc_index: usize,
+    ) -> SupportOption<Vec<(String, BigUint)>> {
+        chain_ops_method!(self, get_holdings_balance, address, rpc_index; await)
     }
-    async fn get_token_decimals(&self, token_address: &str) -> Option<usize> {
-        chain_ops_method!(self, get_token_decimals, token_address; await)
+    async fn get_token_decimals(&self, token_address: &str, rpc_index: usize) -> Option<usize> {
+        chain_ops_method!(self, get_token_decimals, token_address, rpc_index; await)
     }
-    async fn get_token_symbol(&self, token_address: &str) -> Option<String> {
-        chain_ops_method!(self, get_token_symbol, token_address; await)
+    async fn get_token_symbol(&self, token_address: &str, rpc_index: usize) -> Option<String> {
+        chain_ops_method!(self, get_token_symbol, token_address, rpc_index; await)
     }
-    async fn scan_for_tokens(&self, address: &str) -> SupportOption<Vec<Token>> {
-        chain_ops_method!(self, scan_for_tokens, address; await)
+    async fn scan_for_tokens(&self, address: &str, rpc_index: usize) -> SupportOption<Vec<Token>> {
+        chain_ops_method!(self, scan_for_tokens, address, rpc_index; await)
     }
     fn parse_wallet_address(&self, address: &str) -> Option<String> {
         chain_ops_method!(self, parse_wallet_address, address)

src/chain/sol_chain.rs

@@ -35,6 +35,7 @@ impl SolChain {
         &self,
         method: &str,
         params: Value,
+        rpc_index: usize,
     ) -> (Option<T>, Option<f32>) {
         let payload = json!({
             "jsonrpc": "2.0",
@@ -44,7 +45,7 @@ impl SolChain {
         });
         let response = match self
             .http_client
-            .post(self.properties.rpc_url.clone())
+            .post(self.properties.rpc_urls[rpc_index % self.properties.rpc_urls.len()].clone())
             .json(&payload)
             .send()
             .await
@@ -98,24 +99,29 @@ struct SolGetTokenAccountsResponse {
 }
 
 impl ChainOps for SolChain {
-    async fn get_native_token_balance(&self, address: &str) -> (Option<BigUint>, Option<f32>) {
+    async fn get_native_token_balance(
+        &self,
+        address: &str,
+        rpc_index: usize,
+    ) -> (Option<BigUint>, Option<f32>) {
         let (balance, wait_time) = self
-            .rpc_call::<SolGetBalanceResponse>("getBalance", json!([address]))
+            .rpc_call::<SolGetBalanceResponse>("getBalance", json!([address]), rpc_index)
             .await;
         (balance.and_then(|b| BigUint::from_u64(b.value)), wait_time)
     }
     async fn get_token_balance(
         &self,
         token: &Token,
         address: &str,
+        rpc_index: usize,
     ) -> (Option<BigUint>, Option<f32>) {
         let params = json!([
             address,
             { "mint": token.address },
             { "encoding": "jsonParsed" },
         ]);
         let (balances, wait_time) = self
-            .rpc_call::<SolGetTokenBalanceResponse>("getTokenAccountsByOwner", params)
+            .rpc_call::<SolGetTokenBalanceResponse>("getTokenAccountsByOwner", params, rpc_index)
             .await;
         if balances.is_some() && balances.clone().unwrap().token_amounts.len() == 0 {
             return (Some(BigUint::ZERO), wait_time);
@@ -125,29 +131,33 @@ impl ChainOps for SolChain {
             wait_time,
         )
     }
-    async fn get_holdings_balance(&self, _address: &str) -> SupportOption<Vec<(String, BigUint)>> {
+    async fn get_holdings_balance(
+        &self,
+        _address: &str,
+        _rpc_index: usize,
+    ) -> SupportOption<Vec<(String, BigUint)>> {
         SupportOption::Unsupported
     }
-    async fn get_token_decimals(&self, token_address: &str) -> Option<usize> {
+    async fn get_token_decimals(&self, token_address: &str, rpc_index: usize) -> Option<usize> {
         let params = json!([
             token_address,
             { "encoding": "jsonParsed" },
         ]);
         Some(
-            self.rpc_call::<SolGetTokenDecimalsResponse>("getAccountInfo", params)
+            self.rpc_call::<SolGetTokenDecimalsResponse>("getAccountInfo", params, rpc_index)
                 .await
                 .0?
                 .decimals,
         )
     }
-    async fn scan_for_tokens(&self, address: &str) -> SupportOption<Vec<Token>> {
+    async fn scan_for_tokens(&self, address: &str, rpc_index: usize) -> SupportOption<Vec<Token>> {
         let params = json!([
             address,
             { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
             { "encoding": "jsonParsed" },
         ]);
         let tokens_data = self
-            .rpc_call::<SolGetTokenAccountsResponse>("getTokenAccountsByOwner", params)
+            .rpc_call::<SolGetTokenAccountsResponse>("getTokenAccountsByOwner", params, rpc_index)
             .await
             .0
             .to_supported()?

src/chain/token.rs

@@ -19,8 +19,8 @@ impl Token {
         }
     }
     pub async fn new(address: &str, chain: &Chain) -> Option<Self> {
-        let decimals = chain.get_token_decimals(address).await?;
-        let symbol = chain.get_token_symbol(address).await?;
+        let decimals = chain.get_token_decimals(address, 0).await?;
+        let symbol = chain.get_token_symbol(address, 0).await?;
         Some(Self {
             symbol,
             address: chain.parse_token_address(&address)?,

src/chain/ton_chain.rs

@@ -75,7 +75,7 @@ impl TonChain {
     ) -> (Option<T>, Option<f32>) {
         let mut url = Url::parse(&format!(
             "{}/{}",
-            self.properties.rpc_url.to_string(),
+            self.properties.rpc_urls[0].to_string(),
             route
         ))
         .unwrap();
@@ -97,7 +97,11 @@ impl TonChain {
 }
 
 impl ChainOps for TonChain {
-    async fn get_native_token_balance(&self, address: &str) -> (Option<BigUint>, Option<f32>) {
+    async fn get_native_token_balance(
+        &self,
+        address: &str,
+        _rpc_index: usize,
+    ) -> (Option<BigUint>, Option<f32>) {
         let (balance, wait_time) = self
             .api_call::<TonGetAccountResponse>(format!("accounts/{address}"), vec![])
             .await;
@@ -110,6 +114,7 @@ impl ChainOps for TonChain {
         &self,
         token: &Token,
         address: &str,
+        _rpc_index: usize,
     ) -> (Option<BigUint>, Option<f32>) {
         let (balance, wait_time) = self
             .api_call::<TonGetAccountJettonBalanceResponse>(
@@ -122,7 +127,11 @@ impl ChainOps for TonChain {
             wait_time,
         )
     }
-    async fn get_holdings_balance(&self, address: &str) -> SupportOption<Vec<(String, BigUint)>> {
+    async fn get_holdings_balance(
+        &self,
+        address: &str,
+        _rpc_index: usize,
+    ) -> SupportOption<Vec<(String, BigUint)>> {
         let address = self.parse_wallet_address(&address).to_supported()?;
         self.api_call::<TonGetAccountJettonsBalancesResponse>(
             format!("accounts/{}/jettons", address),
@@ -142,7 +151,7 @@ impl ChainOps for TonChain {
         .collect::<Option<_>>()
         .into()
     }
-    async fn get_token_decimals(&self, token_address: &str) -> Option<usize> {
+    async fn get_token_decimals(&self, token_address: &str, _rpc_index: usize) -> Option<usize> {
         usize::from_str(
             &self
                 .api_call::<TonGetJettonInfo>(format!("jettons/{token_address}"), vec![])
@@ -154,7 +163,7 @@ impl ChainOps for TonChain {
         .ok()
         .into()
     }
-    async fn scan_for_tokens(&self, address: &str) -> SupportOption<Vec<Token>> {
+    async fn scan_for_tokens(&self, address: &str, _rpc_index: usize) -> SupportOption<Vec<Token>> {
         let address = self.parse_wallet_address(&address).to_supported()?;
         self.api_call::<TonGetAccountJettonsBalancesResponse>(
             format!("accounts/{}/jettons", address),

src/dexscreener/pairs.rs

@@ -63,7 +63,7 @@ where
                 format!("https://api.dexscreener.com/latest/dex/tokens/{}", t).as_str(),
             )
             .unwrap();
-            let task = async || (get_pairs_request(url.clone()).await, None);
+            let task = async |_rpc_index| (get_pairs_request(url.clone()).await, None);
             let result = handle_retry(task).await;
             if let Some(handler) = progress_handler.as_ref() {
                 handler();