Move swapper out of gemstone

.github/workflows/ci.yml

@@ -35,7 +35,6 @@ jobs:
 
       - name: Build all integration tests only
         run: |
-          just --unstable gemstone build-integration-tests
           just --unstable build-integration-tests
 
       - name: Check gemstone dependencies

Cargo.toml

@@ -43,6 +43,7 @@ members = [
     "crates/number_formatter",
     "crates/pricer_dex",
     "crates/streamer",
+    "crates/gem_swapper",
     "crates/tracing",
 ]
 

bin/gas-bench/src/client.rs

@@ -3,7 +3,8 @@ use std::error::Error;
 use gem_evm::fee_calculator::FeeCalculator;
 use gem_evm::models::fee::EthereumFeeHistory;
 use gem_evm::{ether_conv::EtherConv, jsonrpc::EthereumRpc};
-use gemstone::network::{alien_provider::NativeProvider, jsonrpc_client_with_chain};
+use gemstone::alien::reqwest_provider::NativeProvider;
+use gemstone::network::jsonrpc_client_with_chain;
 use num_bigint::BigInt;
 use primitives::{Chain, PriorityFeeValue, fee::FeePriority};
 use std::fmt::Display;

bin/gas-bench/src/main.rs

@@ -13,7 +13,7 @@ use crate::{
     etherscan::EtherscanClient,
     gasflow::GasflowClient,
 };
-use gemstone::network::alien_provider::NativeProvider;
+use gemstone::alien::reqwest_provider::NativeProvider;
 use primitives::fee::FeePriority;
 
 #[derive(Debug, Clone)]

crates/gem_client/Cargo.toml

@@ -14,4 +14,5 @@ serde_json = { workspace = true }
 serde_urlencoded = { workspace = true }
 reqwest = { workspace = true, optional = true }
 hex = { workspace = true }
-tokio = { workspace = true, features = ["time"], optional = true }
+tokio = { workspace = true, features = ["time"], optional = true }
+primitives = { path = "../primitives" }

crates/gem_client/src/lib.rs

@@ -4,6 +4,8 @@ mod types;
 #[cfg(feature = "reqwest")]
 mod reqwest_client;
 
+pub mod rpc;
+
 #[cfg(feature = "reqwest")]
 pub mod retry;
 
@@ -15,6 +17,7 @@ pub mod query;
 pub use content_type::{ContentType, CONTENT_TYPE};
 pub use query::build_path_with_query;
 pub use types::ClientError;
+pub use rpc::{HttpMethod, RpcClient, RpcProvider, Target, X_CACHE_TTL};
 
 #[cfg(feature = "reqwest")]
 pub use reqwest_client::ReqwestClient;

gemstone/src/network/alien_client.rs → crates/gem_client/src/rpc.rs

@@ -1,18 +1,96 @@
-use crate::network::{AlienError, AlienProvider, AlienTarget};
+use crate::{Client, ClientError, ContentType, Data};
 use async_trait::async_trait;
-use gem_client::{Client, ClientError, ContentType};
 use primitives::Chain;
 use serde::{Serialize, de::DeserializeOwned};
-use std::{collections::HashMap, str::FromStr, sync::Arc};
+use serde_json;
+use std::{collections::HashMap, fmt::Debug, str::FromStr, sync::Arc};
+
+pub const X_CACHE_TTL: &str = "x-cache-ttl";
+
+#[derive(Debug, Clone)]
+pub struct Target {
+    pub url: String,
+    pub method: HttpMethod,
+    pub headers: Option<HashMap<String, String>>,
+    pub body: Option<Vec<u8>>,
+}
+
+impl Target {
+    pub fn get(url: &str) -> Self {
+        Self {
+            url: url.into(),
+            method: HttpMethod::Get,
+            headers: None,
+            body: None,
+        }
+    }
+
+    pub fn post_json(url: &str, body: serde_json::Value) -> Self {
+        Self {
+            url: url.into(),
+            method: HttpMethod::Post,
+            headers: Some(HashMap::from([("Content-Type".into(), "application/json".into())])),
+            body: Some(serde_json::to_vec(&body).expect("Failed to serialize JSON body")),
+        }
+    }
+
+    pub fn set_cache_ttl(mut self, ttl: u64) -> Self {
+        if self.headers.is_none() {
+            self.headers = Some(HashMap::new());
+        }
+        if let Some(headers) = self.headers.as_mut() {
+            headers.insert(X_CACHE_TTL.into(), ttl.to_string());
+        }
+        self
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum HttpMethod {
+    Get,
+    Post,
+    Put,
+    Delete,
+    Head,
+    Options,
+    Patch,
+}
+
+impl From<HttpMethod> for String {
+    fn from(value: HttpMethod) -> Self {
+        match value {
+            HttpMethod::Get => "GET",
+            HttpMethod::Post => "POST",
+            HttpMethod::Put => "PUT",
+            HttpMethod::Delete => "DELETE",
+            HttpMethod::Head => "HEAD",
+            HttpMethod::Options => "OPTIONS",
+            HttpMethod::Patch => "PATCH",
+        }
+        .into()
+    }
+}
+
+#[async_trait]
+pub trait RpcProvider: Send + Sync + Debug {
+    type Error: std::error::Error + Send + Sync + 'static;
+
+    async fn request(&self, target: Target) -> Result<Data, Self::Error>;
+    async fn batch_request(&self, targets: Vec<Target>) -> Result<Vec<Data>, Self::Error>;
+    fn get_endpoint(&self, chain: Chain) -> Result<String, Self::Error>;
+}
 
 #[derive(Debug, Clone)]
-pub struct AlienClient {
+pub struct RpcClient<E> {
     base_url: String,
-    provider: Arc<dyn AlienProvider>,
+    provider: Arc<dyn RpcProvider<Error = E>>,
 }
 
-impl AlienClient {
-    pub fn new(base_url: String, provider: Arc<dyn AlienProvider>) -> Self {
+impl<E> RpcClient<E>
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    pub fn new(base_url: String, provider: Arc<dyn RpcProvider<Error = E>>) -> Self {
         Self { base_url, provider }
     }
 
@@ -22,7 +100,10 @@ impl AlienClient {
 }
 
 #[async_trait]
-impl Client for AlienClient {
+impl<E> Client for RpcClient<E>
+where
+    E: std::error::Error + Send + Sync + 'static + std::fmt::Display,
+{
     async fn get<R>(&self, path: &str) -> Result<R, ClientError>
     where
         R: DeserializeOwned,
@@ -36,21 +117,21 @@ impl Client for AlienClient {
     {
         let url = self.build_url(path);
         let target = if let Some(headers) = headers {
-            AlienTarget {
+            Target {
                 url,
-                method: crate::network::AlienHttpMethod::Get,
+                method: HttpMethod::Get,
                 headers: Some(headers),
                 body: None,
             }
         } else {
-            AlienTarget::get(&url)
+            Target::get(&url)
         };
 
         let response_data = self
             .provider
             .request(target)
             .await
-            .map_err(|e| ClientError::Network(format!("Alien provider error: {e}")))?;
+            .map_err(|e| ClientError::Network(format!("RPC provider error: {e}")))?;
 
         serde_json::from_slice(&response_data).map_err(|e| ClientError::Serialization(format!("Failed to deserialize response: {e}")))
     }
@@ -88,9 +169,9 @@ impl Client for AlienClient {
             _ => serde_json::to_vec(body)?,
         };
 
-        let target = AlienTarget {
+        let target = Target {
             url,
-            method: crate::network::AlienHttpMethod::Post,
+            method: HttpMethod::Post,
             headers: Some(request_headers),
             body: Some(data),
         };
@@ -99,23 +180,28 @@ impl Client for AlienClient {
             .provider
             .request(target)
             .await
-            .map_err(|e| ClientError::Network(format!("Alien provider error: {e}")))?;
+            .map_err(|e| ClientError::Network(format!("RPC provider error: {e}")))?;
 
         serde_json::from_slice(&response_data).map_err(|e| ClientError::Serialization(format!("Failed to deserialize response: {e}")))
     }
 }
 
 #[async_trait]
-impl AlienProvider for AlienClient {
-    async fn request(&self, target: AlienTarget) -> Result<Vec<u8>, AlienError> {
+impl<E> RpcProvider for RpcClient<E>
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    type Error = E;
+
+    async fn request(&self, target: Target) -> Result<Data, Self::Error> {
         self.provider.request(target).await
     }
 
-    async fn batch_request(&self, targets: Vec<AlienTarget>) -> Result<Vec<Vec<u8>>, AlienError> {
+    async fn batch_request(&self, targets: Vec<Target>) -> Result<Vec<Data>, Self::Error> {
         self.provider.batch_request(targets).await
     }
 
-    fn get_endpoint(&self, chain: Chain) -> Result<String, AlienError> {
+    fn get_endpoint(&self, chain: Chain) -> Result<String, Self::Error> {
         self.provider.get_endpoint(chain)
     }
 }

crates/gem_evm/src/rpc/ankr/client.rs

@@ -7,7 +7,7 @@ use serde_json::json;
 
 use crate::rpc::ankr::model::{TokenBalances, Transactions, ankr_chain};
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct AnkrClient<C: Client + Clone> {
     pub chain: EVMChain,
     rpc_client: GenericJsonRpcClient<C>,