feat: consolidate rpc clients and simplify code

Author: wisarmy

examples/pump.rs

@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use anyhow::Result;
 use raytx::{
-    get_rpc_client_blocking,
+    get_rpc_client,
     pump::{get_bonding_curve_account, get_pda, PUMP_PROGRAM},
 };
 use solana_sdk::pubkey::Pubkey;
@@ -18,7 +18,7 @@ async fn main() -> Result<()> {
 }
 
 pub async fn get_bonding_curve_by_mint() -> Result<()> {
-    let client = get_rpc_client_blocking()?;
+    let client = get_rpc_client()?;
     let program_id = Pubkey::from_str(PUMP_PROGRAM)?;
     let mint = Pubkey::from_str("8oAK7mKMSnsVgrBgFS6A4uPqL8dh5NHAc7ohsq71pump")?;
     let bonding_curve = get_pda(&mint, &program_id)?;

examples/rpc.rs

@@ -4,7 +4,7 @@ use amm_cli::load_amm_keys;
 use anyhow::{Context, Result};
 use common::common_utils;
 use futures_util::{SinkExt, StreamExt};
-use raytx::{get_rpc_client_blocking, logger, pump::PUMP_PROGRAM, raydium::get_pool_state_by_mint};
+use raytx::{get_rpc_client, logger, pump::PUMP_PROGRAM, raydium::get_pool_state_by_mint};
 use solana_client::rpc_client::GetConfirmedSignaturesForAddress2Config;
 use solana_sdk::{commitment_config::CommitmentConfig, pubkey::Pubkey};
 use tokio_tungstenite::{connect_async, tungstenite::Message};
@@ -22,7 +22,7 @@ async fn main() -> Result<()> {
 }
 
 pub async fn get_amm_info_by_mint() -> Result<()> {
-    let client = get_rpc_client_blocking()?;
+    let client = get_rpc_client()?;
     let mint = "DrEMQaQqGN2fQwiUgJi6NStLtmni8m3uSkUP678Apump";
 
     let pool_state = get_pool_state_by_mint(client, mint).await?;
@@ -33,7 +33,7 @@ pub async fn get_amm_info_by_mint() -> Result<()> {
 }
 
 pub async fn get_amm_info() -> Result<()> {
-    let client = get_rpc_client_blocking()?;
+    let client = get_rpc_client()?;
     // let amm_pool_id = Pubkey::from_str("3vehHGc8J9doSo6gJoWYG23JG54hc2i7wjdFReX3Rcah")?;
     let amm_pool_id = Pubkey::from_str("7Sp76Pv48RaL4he2BfGUhvjqCtvjjfTSnXDXNvk845yL")?;
 
@@ -94,7 +94,7 @@ pub async fn get_amm_info() -> Result<()> {
 }
 
 pub async fn get_signatures() -> Result<()> {
-    let client = get_rpc_client_blocking()?;
+    let client = get_rpc_client()?;
     let config = GetConfirmedSignaturesForAddress2Config {
         before: None,
         until: None,

src/api.rs

@@ -8,12 +8,12 @@ use axum::{
 };
 use serde::Deserialize;
 use serde_json::json;
-use solana_client::nonblocking::rpc_client::RpcClient;
+use solana_client::rpc_client::RpcClient;
 use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer};
 use tracing::{info, warn};
 
 use crate::{
-    get_rpc_client, get_rpc_client_blocking,
+    get_rpc_client,
     helper::{api_error, api_ok},
     pump::{get_pump_info, RaydiumInfo},
     raydium::Raydium,
@@ -24,7 +24,6 @@ use crate::{
 #[derive(Clone)]
 pub struct AppState {
     pub client: Arc<RpcClient>,
-    pub client_blocking: Arc<solana_client::rpc_client::RpcClient>,
     pub wallet: Arc<Keypair>,
 }
 
@@ -84,15 +83,8 @@ pub async fn get_pool(
             return api_error(&format!("failed to get rpc client: {err}"));
         }
     };
-    let client_blocking = match get_rpc_client_blocking() {
-        Ok(client) => client,
-        Err(err) => {
-            return api_error(&format!("failed to get rpc client: {err}"));
-        }
-    };
     let wallet = state.wallet;
-    let mut swapx = Raydium::new(client, wallet);
-    swapx.with_blocking_client(client_blocking);
+    let swapx = Raydium::new(client, wallet);
     match swapx.get_pool(pool_id.as_str()).await {
         Ok(data) => api_ok(json!({
             "base": data.0,
@@ -115,23 +107,16 @@ pub async fn coins(State(state): State<AppState>, Path(mint): Path<String>) -> i
             return api_error(&format!("failed to get rpc client: {err}"));
         }
     };
-    let client_blocking = match get_rpc_client_blocking() {
-        Ok(client) => client,
-        Err(err) => {
-            return api_error(&format!("failed to get rpc client: {err}"));
-        }
-    };
     let wallet = state.wallet;
     // query from pump.fun
-    let mut pump_info = match get_pump_info(client_blocking.clone(), &mint).await {
+    let mut pump_info = match get_pump_info(client.clone(), &mint).await {
         Ok(info) => info,
         Err(err) => {
             return api_error(&err.to_string());
         }
     };
     if pump_info.complete {
-        let mut swapx = Raydium::new(client, wallet);
-        swapx.with_blocking_client(client_blocking);
+        let swapx = Raydium::new(client, wallet);
         match swapx.get_pool_price(None, Some(mint.as_str())).await {
             Ok(data) => {
                 pump_info.raydium_info = Some(RaydiumInfo {

src/lib.rs

@@ -3,7 +3,7 @@ use std::{env, sync::Arc};
 use anyhow::{anyhow, Result};
 use rand::seq::SliceRandom;
 use reqwest::Proxy;
-use solana_client::nonblocking::rpc_client::RpcClient;
+use solana_client::rpc_client::RpcClient;
 use solana_sdk::signature::Keypair;
 use tracing::debug;
 
@@ -55,12 +55,6 @@ pub fn get_rpc_client() -> Result<Arc<RpcClient>> {
     return Ok(Arc::new(client));
 }
 
-pub fn get_rpc_client_blocking() -> Result<Arc<solana_client::rpc_client::RpcClient>> {
-    let random_url = get_random_rpc_url()?;
-    let client = solana_client::rpc_client::RpcClient::new(random_url);
-    return Ok(Arc::new(client));
-}
-
 pub fn get_wallet() -> Result<Arc<Keypair>> {
     let wallet = Keypair::from_base58_string(&env::var("PRIVATE_KEY")?);
     return Ok(Arc::new(wallet));

src/main.rs

@@ -7,7 +7,7 @@ use axum::{
 use clap::{ArgGroup, Parser, Subcommand};
 use raytx::{
     api::{self, AppState},
-    get_rpc_client, get_rpc_client_blocking, get_wallet, jito, logger,
+    get_rpc_client, get_wallet, jito, logger,
     raydium::get_pool_info,
     swap::{self, SwapDirection, SwapInType},
     token,
@@ -81,13 +81,8 @@ async fn main() -> Result<()> {
     let cli = Cli::parse();
     logger::init();
     let client = get_rpc_client()?;
-    let client_blocking = get_rpc_client_blocking()?;
     let wallet = get_wallet()?;
-    let app_state = AppState {
-        client,
-        client_blocking,
-        wallet,
-    };
+    let app_state = AppState { client, wallet };
 
     match &cli.command {
         Some(Command::Swap {

src/pool.rs

@@ -1,4 +1,4 @@
-use anyhow::{Context, Result};
+use anyhow::Result;
 use common::common_utils;
 use spl_token_2022::amount_to_ui_amount;
 use tracing::{debug, warn};
@@ -26,17 +26,12 @@ impl Raydium {
         pool_id: Option<&str>,
         mint: Option<&str>,
     ) -> Result<(f64, f64, f64)> {
-        let client = self
-            .client_blocking
-            .clone()
-            .context("failed to get rpc client")?;
-
-        let (amm_pool_id, pool_state) = get_pool_state(client.clone(), pool_id, mint).await?;
+        let (amm_pool_id, pool_state) = get_pool_state(self.client.clone(), pool_id, mint).await?;
 
         // debug!("pool_state : {:#?}", pool_state);
 
         let load_pubkeys = vec![pool_state.pc_vault, pool_state.coin_vault];
-        let rsps = common::rpc::get_multiple_accounts(&client, &load_pubkeys).unwrap();
+        let rsps = common::rpc::get_multiple_accounts(&self.client, &load_pubkeys).unwrap();
 
         let amm_pc_vault_account = rsps[0].clone();
         let amm_coin_vault_account = rsps[1].clone();

src/pump.rs

@@ -1,11 +1,11 @@
 use std::{str::FromStr, sync::Arc};
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Result};
 use borsh::from_slice;
 use borsh_derive::{BorshDeserialize, BorshSerialize};
 use raydium_amm::math::U128;
 use serde::{Deserialize, Serialize};
-use solana_client::nonblocking::rpc_client::RpcClient;
+use solana_client::rpc_client::RpcClient;
 use solana_sdk::{
     instruction::{AccountMeta, Instruction},
     pubkey::Pubkey,
@@ -40,24 +40,11 @@ pub const PUMP_SELL_METHOD: u64 = 12502976635542562355;
 pub struct Pump {
     pub client: Arc<RpcClient>,
     pub keypair: Arc<Keypair>,
-    pub client_blocking: Option<Arc<solana_client::rpc_client::RpcClient>>,
 }
 
 impl Pump {
     pub fn new(client: Arc<RpcClient>, keypair: Arc<Keypair>) -> Self {
-        Self {
-            client,
-            keypair,
-            client_blocking: None,
-        }
-    }
-
-    pub fn with_blocking_client(
-        &mut self,
-        client: Arc<solana_client::rpc_client::RpcClient>,
-    ) -> &mut Self {
-        self.client_blocking = Some(client);
-        self
+        Self { client, keypair }
     }
 
     pub async fn swap(
@@ -83,8 +70,7 @@ impl Pump {
         };
         let pump_program = Pubkey::from_str(PUMP_PROGRAM)?;
         let (bonding_curve, associated_bonding_curve, bonding_curve_account) =
-            get_bonding_curve_account(self.client_blocking.clone().unwrap(), &mint, &pump_program)
-                .await?;
+            get_bonding_curve_account(self.client.clone(), &mint, &pump_program).await?;
         let in_ata = get_associated_token_address(&owner, &token_in);
         let out_ata = get_associated_token_address(&owner, &token_out);
 
@@ -169,11 +155,6 @@ impl Pump {
             token_in, amount_ui_pretty, token_out
         );
 
-        let client = self
-            .client_blocking
-            .clone()
-            .context("failed to get rpc client")?;
-
         // Calculate tokens out
         let virtual_sol_reserves = U128::from(bonding_curve_account.virtual_sol_reserves);
         let virtual_token_reserves = U128::from(bonding_curve_account.virtual_token_reserves);
@@ -267,7 +248,7 @@ impl Pump {
             return Err(anyhow!("instructions is empty, no tx required"));
         }
 
-        tx::new_signed_and_send(&client, &self.keypair, instructions, use_jito).await
+        tx::new_signed_and_send(&self.client, &self.keypair, instructions, use_jito).await
     }
 }
 

src/raydium.rs

@@ -6,7 +6,7 @@ use raydium_amm::state::{AmmInfo, Loadable};
 use reqwest::Proxy;
 use serde::Deserialize;
 use solana_client::{
-    nonblocking::rpc_client::RpcClient,
+    rpc_client::RpcClient,
     rpc_filter::{Memcmp, RpcFilterType},
 };
 use solana_sdk::{
@@ -26,7 +26,6 @@ use spl_token_client::token::TokenError;
 use std::{str::FromStr, sync::Arc};
 
 use crate::{
-    get_rpc_client_blocking,
     swap::{SwapDirection, SwapInType},
     token, tx,
 };
@@ -39,7 +38,6 @@ pub const AMM_PROGRAM: &str = "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8";
 pub struct Raydium {
     pub client: Arc<RpcClient>,
     pub keypair: Arc<Keypair>,
-    pub client_blocking: Option<Arc<solana_client::rpc_client::RpcClient>>,
     pub pool_id: Option<String>,
 }
 
@@ -48,19 +46,10 @@ impl Raydium {
         Self {
             client,
             keypair,
-            client_blocking: None,
             pool_id: None,
         }
     }
 
-    pub fn with_blocking_client(
-        &mut self,
-        client: Arc<solana_client::rpc_client::RpcClient>,
-    ) -> &mut Self {
-        self.client_blocking = Some(client);
-        self
-    }
-
     pub fn with_pool_id(&mut self, pool_id: Option<String>) -> &mut Self {
         self.pool_id = pool_id;
         self
@@ -83,12 +72,8 @@ impl Raydium {
         let program_id = spl_token::ID;
         let native_mint = spl_token::native_mint::ID;
 
-        let (amm_pool_id, pool_state) = get_pool_state(
-            self.client_blocking.clone().unwrap(),
-            self.pool_id.as_deref(),
-            Some(mint_str),
-        )
-        .await?;
+        let (amm_pool_id, pool_state) =
+            get_pool_state(self.client.clone(), self.pool_id.as_deref(), Some(mint_str)).await?;
         // debug!("pool_state: {:#?}", pool_state);
 
         let (token_in, token_out, user_input_token, swap_base_in) = match (
@@ -191,9 +176,9 @@ impl Raydium {
 
         let amm_program = Pubkey::from_str(AMM_PROGRAM)?;
         debug!("amm pool id: {amm_pool_id}");
-        let client = get_rpc_client_blocking()?;
+
         let swap_info_result = amm_cli::calculate_swap_info(
-            &client,
+            &self.client,
             amm_program,
             amm_pool_id,
             user_input_token,
@@ -223,8 +208,7 @@ impl Raydium {
             // get rent
             let rent = self
                 .client
-                .get_minimum_balance_for_rent_exemption(Account::LEN)
-                .await?;
+                .get_minimum_balance_for_rent_exemption(Account::LEN)?;
             // if buy add amount_specified
             let total_amount = if token_in == native_mint {
                 rent + amount_specified
@@ -306,7 +290,7 @@ impl Raydium {
             return Err(anyhow!("instructions is empty, no tx required"));
         }
 
-        tx::new_signed_and_send(&client, &self.keypair, instructions, use_jito).await
+        tx::new_signed_and_send(&self.client, &self.keypair, instructions, use_jito).await
     }
 }