Migrate okx to /swaps

Author: gemcoder21

Cargo.lock

@@ -201,24 +201,12 @@ chains:
     url: https://rpc.stable.xyz
 
 swap:
-  jupiter:
-    url: "https://quote-api.jup.ag"
-    key: ""
-    fee:
-      percent: 0
-      address: ""
-  thorchain:
-    url: "https://thornode.ninerealms.com"
-    key: ""
-    fee:
-      percent: 0
-      address: ""
-  aftermath:
-    url: "https://aftermath.finance/api"
-    key: ""
-    fee:
-      percent: 0
-      address: ""
+  okx:
+    key:
+      public: ""
+      secret: ""
+    passphrase: ""
+    project: ""
 scan:
   timeout: 1200ms
   goplus:

Settings.yaml

@@ -51,7 +51,7 @@ use settings::Settings;
 use settings_chain::{ChainProviders, ProviderFactory};
 use storage::Database;
 use streamer::{StreamProducer, StreamProducerConfig};
-use swap::SwapClient;
+use swap::{OkxApiClient, SwapClient};
 use swapper::swapper::GemSwapper;
 use webhooks::WebhooksClient;
 use websocket_prices::PriceObserverConfig;
@@ -96,6 +96,8 @@ fn mount_routes(rocket: Rocket<Build>, admin_enabled: bool) -> Rocket<Build> {
                 chain::transaction::get_transaction,
                 referral::get_rewards_leaderboard,
                 swap::post_near_intents_quote,
+                swap::okx::post_okx_quote,
+                swap::okx::post_okx_quote_data,
             ],
         )
         .mount(
@@ -184,7 +186,8 @@ async fn rocket_api(settings: Settings) -> Result<Rocket<Build>, Box<dyn std::er
     let chain_client = chain::ChainClient::new(ChainProviders::new(ProviderFactory::new_providers(&settings)));
     let portfolio_client = PortfolioClient::new(database.clone(), price_config);
     let endpoints = ProviderFactory::get_chain_endpoints(&settings);
-    let swapper = Arc::new(GemSwapper::new(Arc::new(swapper::NativeProvider::new_with_endpoints(endpoints))));
+    let native_provider = Arc::new(swapper::NativeProvider::new_with_endpoints(endpoints));
+    let swapper = Arc::new(GemSwapper::new(native_provider.clone()));
 
     let retry = streamer::Retry::new(settings.rabbitmq.retry.delay, settings.rabbitmq.retry.timeout);
     let rabbitmq_config = StreamProducerConfig::new(settings.rabbitmq.url.clone(), retry);
@@ -231,6 +234,15 @@ 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 {
+            api_key: settings.swap.okx.key.public.clone(),
+            secret_key: settings.swap.okx.key.secret.clone(),
+            passphrase: settings.swap.okx.passphrase.clone(),
+            project: settings.swap.okx.project.clone(),
+        },
+        native_provider.clone(),
+    );
     let jwt_config = devices::auth_config::JwtConfig {
         secret: settings.api.auth.jwt.secret.clone(),
         expiry: settings.api.auth.jwt.expiry,
@@ -264,6 +276,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(Mutex::new(portfolio_client))
         .manage(auth_client)
         .manage(stream_producer);

apps/api/src/main.rs

@@ -1,8 +1,10 @@
 pub mod client;
 pub mod near_intents;
+pub mod okx;
 
 pub use client::SwapClient;
 pub use near_intents::NearIntentsProxyClient;
+pub use okx::OkxApiClient;
 
 use crate::responders::{ApiError, ApiResponse};
 use primitives::FiatAssets;

apps/api/src/swap/mod.rs

@@ -0,0 +1,32 @@
+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},
+    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())
+}
+
+#[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())
+}

apps/api/src/swap/okx.rs

@@ -27,6 +27,8 @@ pub struct Settings {
     pub paybis: Paybis,
     pub flashnet: UrlKeySettings,
 
+    pub swap: Swap,
+
     pub prices: Prices,
     pub coingecko: CoinGecko,
     pub charter: Charter,
@@ -394,6 +396,18 @@ pub struct Claude {
     pub key: KeySecret,
 }
 
+#[derive(Debug, Deserialize, Clone)]
+pub struct Swap {
+    pub okx: Okx,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Okx {
+    pub key: Key,
+    pub passphrase: String,
+    pub project: String,
+}
+
 #[cfg(feature = "testkit")]
 pub mod testkit;
 

crates/settings/src/lib.rs

@@ -44,6 +44,9 @@ num-integer.workspace = true
 num-traits.workspace = true
 futures.workspace = true
 bs58 = { workspace = true }
+base64 = { workspace = true }
+hmac = { workspace = true }
+sha2 = { workspace = true }
 solana-primitives = "0.2.3"
 bigdecimal.workspace = true
 rand.workspace = true

crates/swapper/Cargo.toml

@@ -1,15 +1,15 @@
 use super::{broker::BrokerClient, client::ChainflipClient, provider::ChainflipProvider};
 use crate::{
     alien::{RpcClient, RpcProvider},
-    config::get_swap_api_url,
+    config::get_swap_proxy_url,
 };
 use gem_jsonrpc::client::JsonRpcClient;
 use std::sync::Arc;
 
 impl ChainflipProvider<RpcClient, RpcClient> {
     pub fn new(rpc_provider: Arc<dyn RpcProvider>) -> Self {
-        let api_url = get_swap_api_url("chainflip-swap");
-        let broker_url = get_swap_api_url("chainflip-broker/rpc");
+        let api_url = get_swap_proxy_url("chainflip-swap");
+        let broker_url = get_swap_proxy_url("chainflip-broker/rpc");
 
         let api_client = RpcClient::new(api_url, rpc_provider.clone());
         let chainflip_client = ChainflipClient::new(api_client.clone());

crates/swapper/src/chainflip/default.rs

@@ -9,10 +9,10 @@ pub const DEFAULT_SWAP_FEE_BPS: u32 = 50;
 pub const DEFAULT_CHAINFLIP_FEE_BPS: u32 = 45;
 pub const DEFAULT_STABLE_SWAP_REFERRAL_BPS: u32 = 25;
 
-pub const API_BASE_URL: &str = "https://api.gemwallet.com/proxy/swap";
+pub const API_BASE_URL: &str = "https://api.gemwallet.com";
 
-pub fn get_swap_api_url(path: &str) -> String {
-    format!("{API_BASE_URL}/{path}")
+pub fn get_swap_proxy_url(path: &str) -> String {
+    format!("{API_BASE_URL}/proxy/swap/{path}")
 }
 
 #[derive(Debug, Clone, PartialEq)]

crates/swapper/src/config.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 
 impl Jupiter<RpcClient, RpcClient> {
     pub fn new(provider: Arc<dyn RpcProvider>) -> Self {
-        let url = config::get_swap_api_url("jupiter");
+        let url = config::get_swap_proxy_url("jupiter");
         let http_client = JupiterClient::new(RpcClient::new(url, provider.clone()));
         let solana_endpoint = provider.get_endpoint(Chain::Solana).expect("Failed to get Solana endpoint for Jupiter provider");
         let rpc_client = JsonRpcClient::new(RpcClient::new(solana_endpoint, provider));