Add Relay swap provider and client for evm chains

crates/swapper/src/across/provider.rs

@@ -362,7 +362,7 @@ impl Swapper for Across {
         ]
     }
 
-    async fn fetch_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
+    async fn get_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
         if request.from_asset.chain() == request.to_asset.chain() {
             return Err(SwapperError::NoQuoteAvailable);
         }
@@ -506,7 +506,7 @@ impl Swapper for Across {
         })
     }
 
-    async fn fetch_quote_data(&self, quote: &Quote, data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
+    async fn get_quote_data(&self, quote: &Quote, data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
         let from_chain = quote.request.from_asset.chain();
         let deployment = AcrossDeployment::deployment_by_chain(&from_chain).ok_or(SwapperError::NotSupportedChain)?;
         let dst_chain_id: u32 = quote.request.to_asset.chain().network_id().parse().unwrap();
@@ -835,14 +835,14 @@ mod tests {
             };
 
             let now = SystemTime::now();
-            let quote = swap_provider.fetch_quote(&request).await?;
+            let quote = swap_provider.get_quote(&request).await?;
             let elapsed = SystemTime::now().duration_since(now).unwrap();
 
             println!("<== elapsed: {:?}", elapsed);
             println!("<== quote: {:?}", quote);
             assert!(quote.to_value.parse::<u64>().unwrap() > 0);
 
-            let quote_data = swap_provider.fetch_quote_data(&quote, FetchQuoteData::EstimateGas).await?;
+            let quote_data = swap_provider.get_quote_data(&quote, FetchQuoteData::EstimateGas).await?;
             println!("<== quote_data: {:?}", quote_data);
 
             Ok(())
@@ -873,14 +873,14 @@ mod tests {
             };
 
             let now = SystemTime::now();
-            let quote = swap_provider.fetch_quote(&request).await?;
+            let quote = swap_provider.get_quote(&request).await?;
             let elapsed = SystemTime::now().duration_since(now).unwrap();
 
             println!("<== elapsed: {:?}", elapsed);
             println!("<== quote: {:?}", quote);
             assert!(quote.to_value.parse::<u64>().unwrap() > 0);
 
-            let quote_data = swap_provider.fetch_quote_data(&quote, FetchQuoteData::EstimateGas).await?;
+            let quote_data = swap_provider.get_quote_data(&quote, FetchQuoteData::EstimateGas).await?;
             println!("<== quote_data: {:?}", quote_data);
 
             Ok(())

crates/swapper/src/chainflip/provider.rs

@@ -148,7 +148,7 @@ where
         ]
     }
 
-    async fn fetch_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
+    async fn get_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
         if request.from_asset.chain().chain_type() == ChainType::Bitcoin {
             return Err(SwapperError::NoQuoteAvailable);
         }
@@ -196,7 +196,7 @@ where
         })
     }
 
-    async fn fetch_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
+    async fn get_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
         let from_asset = quote.request.from_asset.asset_id();
         let source_asset = Self::map_asset_id(&quote.request.from_asset);
         let destination_asset = Self::map_asset_id(&quote.request.to_asset);

crates/swapper/src/fees.rs

@@ -40,7 +40,7 @@ pub fn reserved_tx_fees(chain: Chain) -> Option<&'static str> {
     RESERVED_NATIVE_FEES.get(&chain).copied()
 }
 
-pub fn resolve_max_quote_amount(request: &QuoteRequest) -> Result<String, SwapperError> {
+pub fn resolve_max_quote_value(request: &QuoteRequest) -> Result<String, SwapperError> {
     if !request.options.use_max_amount || !request.from_asset.asset_id().is_native() {
         return Ok(request.value.clone());
     }

crates/swapper/src/hyperliquid/provider/bridge.rs

@@ -48,7 +48,7 @@ impl Swapper for HyperCoreBridge {
         ]
     }
 
-    async fn fetch_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
+    async fn get_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
         let to_value = scale_quote_value(&request.value, request.from_asset.decimals, request.to_asset.decimals)?;
 
         let quote = Quote {
@@ -71,7 +71,7 @@ impl Swapper for HyperCoreBridge {
         Ok(quote)
     }
 
-    async fn fetch_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
+    async fn get_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
         match quote.request.from_asset.asset_id().chain {
             Chain::HyperCore => {
                 let decimals: i32 = quote.request.from_asset.decimals.try_into().unwrap();

crates/swapper/src/hyperliquid/provider/hyperliquid.rs

@@ -54,24 +54,24 @@ impl Swapper for Hyperliquid {
         assets
     }
 
-    async fn fetch_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
+    async fn get_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
         if Self::is_spot_request(request) {
-            return self.spot.fetch_quote(request).await;
+            return self.spot.get_quote(request).await;
         }
 
         if Self::is_bridge_request(request) {
-            return self.bridge.fetch_quote(request).await;
+            return self.bridge.get_quote(request).await;
         }
 
         Err(SwapperError::NoQuoteAvailable)
     }
 
-    async fn fetch_quote_data(&self, quote: &Quote, data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
+    async fn get_quote_data(&self, quote: &Quote, data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
         if Self::is_spot_request(&quote.request) {
-            return self.spot.fetch_quote_data(quote, data).await;
+            return self.spot.get_quote_data(quote, data).await;
         }
         if Self::is_bridge_request(&quote.request) {
-            return self.bridge.fetch_quote_data(quote, data).await;
+            return self.bridge.get_quote_data(quote, data).await;
         }
         Err(SwapperError::NoQuoteAvailable)
     }

crates/swapper/src/hyperliquid/provider/spot/provider.rs

@@ -130,7 +130,7 @@ impl Swapper for HyperCoreSpot {
         )]
     }
 
-    async fn fetch_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
+    async fn get_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
         let client = self.client()?;
         let meta = self.load_spot_meta().await?;
         let from_token = self.resolve_token(&meta, &request.from_asset)?;
@@ -239,7 +239,7 @@ impl Swapper for HyperCoreSpot {
         Ok(quote)
     }
 
-    async fn fetch_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
+    async fn get_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
         let route = quote.data.routes.first().ok_or(SwapperError::InvalidRoute)?;
         let order: PlaceOrder = serde_json::from_str(&route.route_data).map_err(|_| SwapperError::InvalidRoute)?;
         let order_json = serde_json::to_string(&order).map_err(|err| SwapperError::TransactionError(err.to_string()))?;
@@ -270,13 +270,13 @@ mod tests {
         request.options.preferred_providers = vec![SwapperProvider::Hyperliquid];
         request.value = "2000000000".into();
 
-        let quote = spot.fetch_quote(&request).await.unwrap();
+        let quote = spot.get_quote(&request).await.unwrap();
 
         let order: PlaceOrder = serde_json::from_str(&quote.data.routes[0].route_data).unwrap();
         assert_eq!(order.r#type, "order");
         assert!(order.orders[0].asset >= SPOT_ASSET_OFFSET);
 
-        let quote_data = spot.fetch_quote_data(&quote, FetchQuoteData::None).await.unwrap();
+        let quote_data = spot.get_quote_data(&quote, FetchQuoteData::None).await.unwrap();
         assert_eq!(quote.data.provider.id, SwapperProvider::Hyperliquid);
         assert!(!quote.to_value.is_empty());
         assert!(matches!(quote_data.data_type, SwapQuoteDataType::Contract));

crates/swapper/src/jupiter/provider.rs

@@ -122,7 +122,7 @@ where
         vec![SwapperChainAsset::All(Chain::Solana)]
     }
 
-    async fn fetch_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
+    async fn get_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
         let input_mint = self.get_asset_address(&request.from_asset.id)?;
         let output_mint = self.get_asset_address(&request.to_asset.id)?;
         let swap_options = request.options.clone();
@@ -162,7 +162,7 @@ where
         Ok(quote)
     }
 
-    async fn fetch_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
+    async fn get_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
         if quote.data.routes.is_empty() {
             return Err(SwapperError::InvalidRoute);
         }
@@ -220,7 +220,7 @@ mod swap_integration_tests {
             options,
         };
 
-        let quote = provider.fetch_quote(&request).await?;
+        let quote = provider.get_quote(&request).await?;
 
         assert_eq!(quote.from_value, request.value);
         assert!(quote.to_value.parse::<u64>().unwrap() > 0);
@@ -236,7 +236,7 @@ mod swap_integration_tests {
         assert_eq!(quote_response.input_mint, "So11111111111111111111111111111111111111112");
         assert_eq!(quote_response.output_mint, USDC_TOKEN_MINT);
 
-        let quote_data = provider.fetch_quote_data(&quote, FetchQuoteData::None).await?;
+        let quote_data = provider.get_quote_data(&quote, FetchQuoteData::None).await?;
         assert_eq!(quote_data.to, PROGRAM_ADDRESS);
         assert!(!quote_data.data.is_empty());
 

crates/swapper/src/models.rs

@@ -47,7 +47,7 @@ impl ProviderType {
             | SwapperProvider::Okx => SwapProviderMode::OnChain,
             SwapperProvider::Mayan | SwapperProvider::Chainflip | SwapperProvider::NearIntents => SwapProviderMode::CrossChain,
             SwapperProvider::Thorchain => SwapProviderMode::OmniChain(vec![Chain::Thorchain, Chain::Tron]),
-            SwapperProvider::Relay => SwapProviderMode::OmniChain(vec![Chain::Hyperliquid, Chain::Manta, Chain::Berachain]),
+            SwapperProvider::Relay => SwapProviderMode::OmniChain(vec![Chain::Hyperliquid, Chain::Berachain]),
             SwapperProvider::Across => SwapProviderMode::Bridge,
             SwapperProvider::Hyperliquid => SwapProviderMode::OmniChain(vec![Chain::HyperCore, Chain::Hyperliquid]),
         }

crates/swapper/src/near_intents/provider.rs

@@ -9,7 +9,7 @@ use crate::{
     SwapperProvider, SwapperQuoteAsset, SwapperQuoteData, amount_to_value,
     client_factory::create_client_with_chain,
     cross_chain::VaultAddresses,
-    fees::resolve_max_quote_amount,
+    fees::resolve_max_quote_value,
     near_intents::client::{base_url, explorer_url},
     referrer::DEFAULT_REFERRER,
 };
@@ -282,13 +282,13 @@ where
         self.supported_assets.clone()
     }
 
-    async fn fetch_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
+    async fn get_quote(&self, request: &QuoteRequest) -> Result<Quote, SwapperError> {
         let mode = match request.mode {
             SwapperMode::ExactIn => SwapType::FlexInput,
             SwapperMode::ExactOut => return Err(SwapperError::NotSupportedAsset),
         };
 
-        let amount = resolve_max_quote_amount(request)?;
+        let amount = resolve_max_quote_value(request)?;
         let quote_request = self.build_quote_request(request, mode, amount.clone(), true)?;
         let response = Self::extract_quote(self.client.fetch_quote(&quote_request).await?, request.from_asset.decimals)?;
         let amount_out = Self::parse_amount(&response.quote.amount_out, "amountOut")?;
@@ -314,7 +314,7 @@ where
         })
     }
 
-    async fn fetch_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
+    async fn get_quote_data(&self, quote: &Quote, _data: FetchQuoteData) -> Result<SwapperQuoteData, SwapperError> {
         let route = quote.data.routes.first().ok_or(SwapperError::InvalidRoute)?;
         let mut quote_request: NearQuoteRequest = serde_json::from_str(&route.route_data)?;
         let request_deposit_mode = quote_request.deposit_mode.clone();
@@ -425,7 +425,7 @@ mod tests {
         let amount = (reserve + U256::from(500u64)).to_string();
 
         let request = build_quote_request(&amount, true, Chain::Ethereum);
-        let result = resolve_max_quote_amount(&request).expect("expected amount to resolve");
+        let result = resolve_max_quote_value(&request).expect("expected amount to resolve");
 
         assert_eq!(result, (U256::from_str(&amount).unwrap() - reserve).to_string());
     }
@@ -434,7 +434,7 @@ mod tests {
     fn resolve_quote_amount_without_use_max_keeps_amount() {
         let amount = "123456";
         let request = build_quote_request(amount, false, Chain::Ethereum);
-        let result = resolve_max_quote_amount(&request).expect("expected amount to resolve");
+        let result = resolve_max_quote_value(&request).expect("expected amount to resolve");
 
         assert_eq!(result, amount);
     }
@@ -444,7 +444,7 @@ mod tests {
         let reserve = U256::from_str(reserved_tx_fees(Chain::Ethereum).unwrap()).unwrap();
         let request = build_quote_request(&reserve.to_string(), true, Chain::Ethereum);
 
-        let err = resolve_max_quote_amount(&request).expect_err("expected error");
+        let err = resolve_max_quote_value(&request).expect_err("expected error");
 
         assert!(matches!(err, SwapperError::InputAmountError { .. }));
     }
@@ -556,7 +556,6 @@ mod swap_integration_tests {
     use primitives::{
         AssetId, Chain,
         asset_constants::{USDC_ARB_ASSET_ID, USDC_BASE_ASSET_ID},
-        swap::SwapStatus,
     };
     use std::sync::Arc;
 
@@ -588,10 +587,10 @@ mod swap_integration_tests {
             options,
         };
 
-        let quote = provider.fetch_quote(&request).await?;
+        let quote = provider.get_quote(&request).await?;
         assert!(!quote.to_value.is_empty());
 
-        let quote_data = provider.fetch_quote_data(&quote, FetchQuoteData::None).await?;
+        let quote_data = provider.get_quote_data(&quote, FetchQuoteData::None).await?;
         assert!(!quote_data.to.is_empty());
 
         Ok(())
@@ -617,12 +616,12 @@ mod swap_integration_tests {
             options,
         };
 
-        let quote = match provider.fetch_quote(&request).await {
+        let quote = match provider.get_quote(&request).await {
             Ok(quote) => quote,
             Err(SwapperError::ComputeQuoteError(_)) => return Ok(()),
             Err(error) => return Err(error),
         };
-        let quote_data = match provider.fetch_quote_data(&quote, FetchQuoteData::None).await {
+        let quote_data = match provider.get_quote_data(&quote, FetchQuoteData::None).await {
             Ok(data) => data,
             Err(SwapperError::TransactionError(_)) => return Ok(()),
             Err(error) => return Err(error),