Improve OkxProvider

gemcoder21 · gemcoder21 · commit a2239e51bf5d · 2026-05-12T21:29:35.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/apps/api/src/main.rs b/apps/api/src/main.rs
@@ -51,7 +51,8 @@ use settings::Settings;
 use settings_chain::{ChainProviders, ProviderFactory};
 use storage::Database;
 use streamer::{StreamProducer, StreamProducerConfig};
-use swap::{OkxApiClient, SwapClient};
+use swap::SwapClient;
+use swapper::okx::{OkxClientConfig, OkxProvider};
 use swapper::swapper::GemSwapper;
 use webhooks::WebhooksClient;
 use websocket_prices::PriceObserverConfig;
@@ -234,8 +235,8 @@ async fn rocket_api(settings: Settings) -> Result<Rocket<Build>, Box<dyn std::er
     let redemption_client = RewardsRedemptionClient::new(database.clone(), stream_producer.clone());
     let notifications_client = NotificationsClient::new(database.clone());
     let near_intents_client = swap::NearIntentsProxyClient::new(cacher_client.clone());
-    let okx_api_client = OkxApiClient::new(
-        swapper::okx::OkxClientConfig {
+    let okx_provider = OkxProvider::new(
+        OkxClientConfig {
             api_key: settings.swap.okx.key.public.clone(),
             secret_key: settings.swap.okx.key.secret.clone(),
             passphrase: settings.swap.okx.passphrase.clone(),
@@ -276,7 +277,7 @@ async fn rocket_api(settings: Settings) -> Result<Rocket<Build>, Box<dyn std::er
         .manage(Mutex::new(wallets_client))
         .manage(Mutex::new(notifications_client))
         .manage(Mutex::new(near_intents_client))
-        .manage(okx_api_client)
+        .manage(okx_provider)
         .manage(Mutex::new(portfolio_client))
         .manage(auth_client)
         .manage(stream_producer);
diff --git a/apps/api/src/swap/mod.rs b/apps/api/src/swap/mod.rs
@@ -4,7 +4,6 @@ pub mod okx;
 
 pub use client::SwapClient;
 pub use near_intents::NearIntentsProxyClient;
-pub use okx::OkxApiClient;
 
 use crate::responders::{ApiError, ApiResponse};
 use primitives::FiatAssets;
diff --git a/apps/api/src/swap/okx.rs b/apps/api/src/swap/okx.rs
@@ -1,32 +1,17 @@
-use gem_client::ReqwestClient;
 use primitives::swap::{ProxyQuote, ProxyQuoteRequest, SwapQuoteData};
 use rocket::serde::json::Json;
-use std::sync::Arc;
 use swapper::{
-    RpcProvider,
-    okx::{BASE_URL, OkxClientConfig, OkxProvider},
+    RpcClient,
+    okx::OkxProvider,
     proxy::ProxyResponse,
 };
 
-pub struct OkxApiClient {
-    provider: OkxProvider<ReqwestClient>,
-}
-
-impl OkxApiClient {
-    pub fn new(config: OkxClientConfig, rpc_provider: Arc<dyn RpcProvider>) -> Self {
-        let http = ReqwestClient::new(BASE_URL.to_string(), reqwest::Client::new());
-        Self {
-            provider: OkxProvider::new(http, config, rpc_provider),
-        }
-    }
-}
-
 #[rocket::post("/swaps/providers/okx/quote", data = "<body>")]
-pub async fn post_okx_quote(body: Json<ProxyQuoteRequest>, client: &rocket::State<OkxApiClient>) -> Json<ProxyResponse<ProxyQuote>> {
-    Json(client.provider.compute_quote(body.into_inner()).await.into())
+pub async fn post_okx_quote(body: Json<ProxyQuoteRequest>, provider: &rocket::State<OkxProvider<RpcClient>>) -> Json<ProxyResponse<ProxyQuote>> {
+    Json(provider.get_quote(body.into_inner()).await.into())
 }
 
 #[rocket::post("/swaps/providers/okx/quote_data", data = "<body>")]
-pub async fn post_okx_quote_data(body: Json<ProxyQuote>, client: &rocket::State<OkxApiClient>) -> Json<ProxyResponse<SwapQuoteData>> {
-    Json(client.provider.compute_quote_data(body.into_inner()).await.into())
+pub async fn post_okx_quote_data(body: Json<ProxyQuote>, provider: &rocket::State<OkxProvider<RpcClient>>) -> Json<ProxyResponse<SwapQuoteData>> {
+    Json(provider.get_quote_data(body.into_inner()).await.into())
 }
diff --git a/crates/gem_solana/src/provider/balances.rs b/crates/gem_solana/src/provider/balances.rs
@@ -60,14 +60,14 @@ mod chain_integration_tests {
     use super::*;
     use crate::{
         PYUSD_TOKEN_MINT, USDC_TOKEN_MINT, USDT_TOKEN_MINT,
-        provider::testkit::{TEST_ADDRESS, create_solana_test_client},
+        provider::testkit::create_solana_test_client,
     };
-    use primitives::Chain;
+    use primitives::{Chain, testkit::signer_mock::TEST_SOLANA_SENDER};
 
     #[tokio::test]
     async fn test_solana_get_balance_coin() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let client = create_solana_test_client();
-        let balance = client.get_balance_coin(TEST_ADDRESS.to_string()).await?;
+        let balance = client.get_balance_coin(TEST_SOLANA_SENDER.to_string()).await?;
 
         assert_eq!(balance.asset_id.chain, Chain::Solana);
         assert_eq!(balance.asset_id.token_id, None);
@@ -81,7 +81,7 @@ mod chain_integration_tests {
         let client = create_solana_test_client();
         let token_ids = vec![USDC_TOKEN_MINT.to_string(), USDT_TOKEN_MINT.to_string(), PYUSD_TOKEN_MINT.to_string()];
 
-        let balances = client.get_balance_tokens(TEST_ADDRESS.to_string(), token_ids.clone()).await?;
+        let balances = client.get_balance_tokens(TEST_SOLANA_SENDER.to_string(), token_ids.clone()).await?;
 
         assert_eq!(balances.len(), token_ids.len());
         for (i, balance) in balances.iter().enumerate() {
@@ -96,7 +96,7 @@ mod chain_integration_tests {
     #[tokio::test]
     async fn test_solana_get_balance_staking() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let client = create_solana_test_client();
-        let staking_balance = client.get_balance_staking(TEST_ADDRESS.to_string()).await?;
+        let staking_balance = client.get_balance_staking(TEST_SOLANA_SENDER.to_string()).await?;
 
         if let Some(balance) = staking_balance {
             assert_eq!(balance.asset_id.chain, Chain::Solana);
@@ -110,7 +110,7 @@ mod chain_integration_tests {
     #[tokio::test]
     async fn test_solana_get_balance_assets() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let client = create_solana_test_client();
-        let address = TEST_ADDRESS.to_string();
+        let address = TEST_SOLANA_SENDER.to_string();
         let assets = client.get_balance_assets(address).await?;
 
         for asset in assets {
diff --git a/crates/gem_solana/src/provider/preload.rs b/crates/gem_solana/src/provider/preload.rs
@@ -78,7 +78,8 @@ impl<C: Client + Clone> ChainTransactionLoad for SolanaClient<C> {
 #[cfg(all(test, feature = "chain_integration_tests"))]
 mod chain_integration_tests {
     use super::*;
-    use crate::provider::testkit::{TEST_ADDRESS, TEST_EMPTY_ADDRESS, create_solana_test_client};
+    use primitives::testkit::signer_mock::TEST_SOLANA_SENDER;
+    use crate::provider::testkit::{ TEST_EMPTY_ADDRESS, create_solana_test_client};
     use primitives::swap::SwapData;
     use primitives::{Asset, SwapProvider};
 
@@ -95,8 +96,8 @@ mod chain_integration_tests {
         let client = create_solana_test_client();
         let input = TransactionPreloadInput {
             input_type: TransactionInputType::Transfer(Asset::mock_sol()),
-            sender_address: TEST_ADDRESS.to_string(),
-            destination_address: TEST_ADDRESS.to_string(),
+            sender_address: TEST_SOLANA_SENDER.to_string(),
+            destination_address: TEST_SOLANA_SENDER.to_string(),
         };
         let result = client.get_transaction_preload(input).await?;
 
@@ -114,7 +115,7 @@ mod chain_integration_tests {
         let client = create_solana_test_client();
         let input = TransactionPreloadInput {
             input_type: TransactionInputType::Transfer(Asset::mock_spl_token()),
-            sender_address: TEST_ADDRESS.to_string(),
+            sender_address: TEST_SOLANA_SENDER.to_string(),
             destination_address: "4BgapREafMMprtU6CehRmH8LUY26PRFmGf7K4S44oSMW".to_string(),
         };
 
@@ -135,8 +136,8 @@ mod chain_integration_tests {
         let swap_data = SwapData::mock_with_provider(SwapProvider::Jupiter);
         let input = TransactionPreloadInput {
             input_type: TransactionInputType::Swap(Asset::mock_spl_token().clone(), Asset::mock_ethereum_usdc().clone(), swap_data),
-            sender_address: TEST_ADDRESS.to_string(),
-            destination_address: TEST_ADDRESS.to_string(),
+            sender_address: TEST_SOLANA_SENDER.to_string(),
+            destination_address: TEST_SOLANA_SENDER.to_string(),
         };
 
         let result = client.get_transaction_preload(input).await?;
@@ -161,7 +162,7 @@ mod chain_integration_tests {
         let swap_data = SwapData::mock_with_provider(SwapProvider::Jupiter);
         let input = TransactionPreloadInput {
             input_type: TransactionInputType::Swap(Asset::mock_spl_token(), Asset::mock_spl_token(), swap_data),
-            sender_address: TEST_ADDRESS.to_string(),
+            sender_address: TEST_SOLANA_SENDER.to_string(),
             destination_address: TEST_EMPTY_ADDRESS.to_string(),
         };
 
diff --git a/crates/gem_solana/src/provider/staking.rs b/crates/gem_solana/src/provider/staking.rs
@@ -40,7 +40,8 @@ impl<C: Client + Clone> ChainStaking for SolanaClient<C> {
 #[cfg(all(test, feature = "chain_integration_tests"))]
 mod chain_integration_tests {
     use super::*;
-    use crate::provider::testkit::{TEST_ADDRESS, create_solana_test_client};
+    use primitives::testkit::signer_mock::TEST_SOLANA_SENDER;
+    use crate::provider::testkit::{ create_solana_test_client};
 
     #[tokio::test]
     async fn test_solana_get_staking_apy() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
@@ -62,7 +63,7 @@ mod chain_integration_tests {
     #[tokio::test]
     async fn test_solana_get_staking_delegations() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let client = create_solana_test_client();
-        let delegations = client.get_staking_delegations(TEST_ADDRESS.to_string()).await?;
+        let delegations = client.get_staking_delegations(TEST_SOLANA_SENDER.to_string()).await?;
         assert!(delegations.len() <= 100);
         Ok(())
     }
diff --git a/crates/gem_solana/src/provider/testkit.rs b/crates/gem_solana/src/provider/testkit.rs
@@ -7,8 +7,6 @@ use gem_jsonrpc::JsonRpcClient;
 #[cfg(feature = "chain_integration_tests")]
 use settings::testkit::get_test_settings;
 
-#[cfg(feature = "chain_integration_tests")]
-pub const TEST_ADDRESS: &str = "8wytzyCBXco7yqgrLDiecpEt452MSuNWRe7xsLgAAX1H";
 #[cfg(feature = "chain_integration_tests")]
 pub const TEST_EMPTY_ADDRESS: &str = "EniLGJRPvjbD51z5r59HRN4XoeMmRC4zMtHNHBKi1sFA";
 #[cfg(test)]
diff --git a/crates/gem_solana/src/provider/transactions.rs b/crates/gem_solana/src/provider/transactions.rs
@@ -52,7 +52,8 @@ impl<C: Client + Clone> ChainTransactions for SolanaClient<C> {
 #[cfg(all(test, feature = "chain_integration_tests"))]
 mod chain_integration_tests {
     use super::*;
-    use crate::provider::testkit::{TEST_ADDRESS, TEST_TRANSACTION_ID, create_solana_test_client};
+    use primitives::testkit::signer_mock::TEST_SOLANA_SENDER;
+    use crate::provider::testkit::{ TEST_TRANSACTION_ID, create_solana_test_client};
     use chain_traits::ChainState;
 
     #[tokio::test]
@@ -70,9 +71,9 @@ mod chain_integration_tests {
     #[tokio::test]
     async fn test_solana_get_transactions_by_address() {
         let client = create_solana_test_client();
-        let transactions = client.get_transactions_by_address(TransactionsRequest::new(TEST_ADDRESS.to_string())).await.unwrap();
+        let transactions = client.get_transactions_by_address(TransactionsRequest::new(TEST_SOLANA_SENDER.to_string())).await.unwrap();
 
-        println!("Address: {}, transactions count: {}", TEST_ADDRESS, transactions.len());
+        println!("Address: {}, transactions count: {}", TEST_SOLANA_SENDER, transactions.len());
     }
 
     #[tokio::test]
diff --git a/crates/primitives/src/testkit/signer_mock.rs b/crates/primitives/src/testkit/signer_mock.rs
@@ -2,3 +2,5 @@ pub const TEST_PRIVATE_KEY: [u8; 32] = [1u8; 32];
 pub const TEST_EVM_SENDER: &str = "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf";
 pub const TEST_EVM_RECIPIENT: &str = "0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF";
 pub const TEST_OSMOSIS_SENDER: &str = "osmo1kglemumu8mn658j6g4z9jzn3zef2qdyyvklwa3";
+pub const TEST_SOLANA_SENDER: &str = "8wytzyCBXco7yqgrLDiecpEt452MSuNWRe7xsLgAAX1H";
+pub const TEST_TON_SENDER: &str = "UQAzoUpalAaXnVm5MoiYWRZguLFzY0KxFjLv3MkRq5BXz3VV";
diff --git a/crates/swapper/Cargo.toml b/crates/swapper/Cargo.toml
@@ -56,3 +56,4 @@ tracing = "0.1.44"
 tokio.workspace = true
 primitives = { path = "../primitives", features = ["testkit"] }
 gem_client = { path = "../gem_client", features = ["testkit"] }
+settings = { path = "../settings", features = ["testkit"] }
diff --git a/crates/swapper/src/okx/mod.rs b/crates/swapper/src/okx/mod.rs
@@ -4,6 +4,5 @@ mod constants;
 mod model;
 mod provider;
 
-pub use constants::BASE_URL;
 pub use model::OkxClientConfig;
 pub use provider::OkxProvider;
diff --git a/crates/swapper/src/okx/provider.rs b/crates/swapper/src/okx/provider.rs
@@ -1,11 +1,11 @@
 use super::{
     client::OkxDexClient,
-    constants::{EVM_NATIVE_TOKEN_ADDRESS, SOLANA_NATIVE_TOKEN_ADDRESS, chain_index, dex_ids, evm_gas_limit},
+    constants::{BASE_URL, EVM_NATIVE_TOKEN_ADDRESS, SOLANA_NATIVE_TOKEN_ADDRESS, chain_index, dex_ids, evm_gas_limit},
     model::{OkxApiResponse, OkxClientConfig, QuoteData, QuoteParams, SwapParams, TransactionData},
 };
 use crate::{
     SwapperError,
-    alien::RpcProvider,
+    alien::{RpcClient, RpcProvider},
     approval::check_approval_erc20,
     fees::{bps_to_percent_string, default_referral_fees},
     models::ApprovalType,
@@ -33,18 +33,24 @@ where
     rpc_provider: Arc<dyn RpcProvider>,
 }
 
+impl OkxProvider<RpcClient> {
+    pub fn new(config: OkxClientConfig, rpc_provider: Arc<dyn RpcProvider>) -> Self {
+        Self::new_with_client(RpcClient::new(BASE_URL.to_string(), rpc_provider.clone()), config, rpc_provider)
+    }
+}
+
 impl<C> OkxProvider<C>
 where
     C: Client + Clone + Send + Sync + Debug + 'static,
 {
-    pub fn new(client: C, config: OkxClientConfig, rpc_provider: Arc<dyn RpcProvider>) -> Self {
+    pub fn new_with_client(client: C, config: OkxClientConfig, rpc_provider: Arc<dyn RpcProvider>) -> Self {
         Self {
             client: OkxDexClient::new(client, config),
             rpc_provider,
         }
     }
 
-    pub async fn compute_quote(&self, request: ProxyQuoteRequest) -> Result<ProxyQuote, SwapperError> {
+    pub async fn get_quote(&self, request: ProxyQuoteRequest) -> Result<ProxyQuote, SwapperError> {
         let chain = request.from_asset.chain();
         if request.to_asset.chain() != chain {
             return Err(SwapperError::NotSupportedChain);
@@ -75,7 +81,7 @@ where
         })
     }
 
-    pub async fn compute_quote_data(&self, quote: ProxyQuote) -> Result<SwapQuoteData, SwapperError> {
+    pub async fn get_quote_data(&self, quote: ProxyQuote) -> Result<SwapQuoteData, SwapperError> {
         let route: QuoteData = serde_json::from_value(quote.route_data.clone()).map_err(|_| SwapperError::InvalidRoute)?;
         let request = &quote.quote;
         let chain = request.from_asset.chain();
@@ -370,3 +376,46 @@ mod tests {
         assert!(sol_params.to_token_referrer_wallet_address.is_none());
     }
 }
+
+#[cfg(all(test, feature = "swap_integration_tests"))]
+mod swap_integration_tests {
+    use super::*;
+    use crate::alien::reqwest_provider::NativeProvider;
+    use primitives::{AssetId, asset_constants::SOLANA_USDC_ASSET_ID, swap::QuoteAsset, testkit::signer_mock::TEST_SOLANA_SENDER};
+
+    fn okx_provider() -> OkxProvider<RpcClient> {
+        let settings = settings::testkit::get_test_settings();
+        let config = OkxClientConfig {
+            api_key: settings.swap.okx.key.public,
+            secret_key: settings.swap.okx.key.secret,
+            passphrase: settings.swap.okx.passphrase,
+            project: settings.swap.okx.project,
+        };
+        OkxProvider::new(config, Arc::new(NativeProvider::default()))
+    }
+
+    #[tokio::test]
+    async fn test_okx_fetch_quote_and_quote_data_sol_to_usdc() -> Result<(), SwapperError> {
+        let provider = okx_provider();
+        let request = ProxyQuoteRequest {
+            from_address: TEST_SOLANA_SENDER.to_string(),
+            to_address: TEST_SOLANA_SENDER.to_string(),
+            from_asset: QuoteAsset::from(AssetId::from_chain(Chain::Solana)),
+            to_asset: QuoteAsset::from(SOLANA_USDC_ASSET_ID.clone()),
+            from_value: "100000000".to_string(),
+            referral_bps: 50,
+            slippage_bps: 300,
+            use_max_amount: false,
+        };
+
+        let quote = provider.get_quote(request).await?;
+        assert!(quote.output_value.parse::<u64>().unwrap() > 0);
+        assert!(quote.output_min_value.parse::<u64>().unwrap() > 0);
+
+        let quote_data = provider.get_quote_data(quote).await?;
+        assert!(!quote_data.to.is_empty());
+        assert_eq!(quote_data.value, "0");
+        assert!(!quote_data.data.is_empty());
+        Ok(())
+    }
+}
diff --git a/crates/swapper/src/stonfi/provider.rs b/crates/swapper/src/stonfi/provider.rs
@@ -321,15 +321,15 @@ mod swap_integration_tests {
         Options, SwapperQuoteAsset,
         alien::reqwest_provider::NativeProvider,
         stonfi::testkit::NOT_TOKEN_ID,
-        testkit::{TEST_TON_WALLET_ADDRESS, mock_ton},
+        testkit::mock_ton,
     };
-    use primitives::{AssetId, asset_constants::TON_USDT_ASSET_ID};
+    use primitives::{AssetId, asset_constants::TON_USDT_ASSET_ID, testkit::signer_mock::TEST_TON_SENDER};
 
     #[tokio::test]
     async fn test_stonfi_fetch_quote_and_quote_data_ton_to_usdt() -> Result<(), SwapperError> {
         let rpc_provider = Arc::new(NativeProvider::default());
         let provider = Stonfi::new(rpc_provider);
-        let request = mock_ton(TEST_TON_WALLET_ADDRESS.to_string());
+        let request = mock_ton(TEST_TON_SENDER.to_string());
 
         let quote = provider.get_quote(&request).await?;
         assert_eq!(quote.from_value, request.value);
@@ -354,8 +354,8 @@ mod swap_integration_tests {
         let request = QuoteRequest {
             from_asset: SwapperQuoteAsset::from(AssetId::from_token(Chain::Ton, NOT_TOKEN_ID)),
             to_asset: SwapperQuoteAsset::from(TON_USDT_ASSET_ID.clone()),
-            wallet_address: TEST_TON_WALLET_ADDRESS.to_string(),
-            destination_address: TEST_TON_WALLET_ADDRESS.to_string(),
+            wallet_address: TEST_TON_SENDER.to_string(),
+            destination_address: TEST_TON_SENDER.to_string(),
             value: "1000000000000".to_string(),
             options: Options::new_with_slippage(100.into()),
         };
diff --git a/crates/swapper/src/stonfi/testkit.rs b/crates/swapper/src/stonfi/testkit.rs
@@ -1,4 +1,4 @@
-pub use crate::testkit::TEST_TON_WALLET_ADDRESS;
+pub use primitives::testkit::signer_mock::TEST_TON_SENDER;
 
 use super::{
     model::{Router, SwapSimulation},
@@ -35,10 +35,10 @@ impl<'a> SwapTransactionParams<'a> {
             to_native: false,
             sender_jetton_wallet: None,
             from_value: "1000000000",
-            wallet_address: Address::parse(TEST_TON_WALLET_ADDRESS).unwrap(),
-            receiver_address: Address::parse(TEST_TON_WALLET_ADDRESS).unwrap(),
+            wallet_address: Address::parse(TEST_TON_SENDER).unwrap(),
+            receiver_address: Address::parse(TEST_TON_SENDER).unwrap(),
             referral: ReferralParams {
-                address: Address::parse(TEST_TON_WALLET_ADDRESS).unwrap(),
+                address: Address::parse(TEST_TON_SENDER).unwrap(),
                 bps: 50,
             },
             deadline: Some(1_700_000_000),
diff --git a/crates/swapper/src/testkit.rs b/crates/swapper/src/testkit.rs
