Refactor Paybis quote handling to use quote_id

gemcoder21 · gemcoder21 · commit a7b33c20a61c · 2025-11-25T02:44:23.000Z
Updated Paybis request and provider logic to use quote_id instead of requested_amount/requested_amount_type. Adjusted related method signatures, struct fields, and tests to reflect this change. Added a mock_sell method for FiatQuoteRequest in testkit for improved test coverage.
diff --git a/apps/dynode/src/config/domain.rs b/apps/dynode/src/config/domain.rs
@@ -137,7 +137,10 @@ mod tests {
     fn resolve_url_without_override() {
         let chain_config = make_chain_config(None, None);
         let base_url = make_url("https://example.com/rpc");
-        assert_eq!(chain_config.resolve_url(&base_url, Some("eth_sendTransaction"), None).url, "https://example.com/rpc");
+        assert_eq!(
+            chain_config.resolve_url(&base_url, Some("eth_sendTransaction"), None).url,
+            "https://example.com/rpc"
+        );
     }
 
     #[test]
@@ -176,7 +179,10 @@ mod tests {
             url: "https://tx-relay.example.com".to_string(),
         }]);
         let base_url = make_url("https://example.com/rpc");
-        assert_eq!(chain_config.resolve_url(&base_url, Some("eth_blockNumber"), None).url, "https://example.com/rpc");
+        assert_eq!(
+            chain_config.resolve_url(&base_url, Some("eth_blockNumber"), None).url,
+            "https://example.com/rpc"
+        );
     }
 
     #[test]
diff --git a/apps/dynode/src/config/mod.rs b/apps/dynode/src/config/mod.rs
@@ -1,4 +1,8 @@
-use std::{collections::HashMap, env, fs, path::{Path, PathBuf}};
+use std::{
+    collections::HashMap,
+    env, fs,
+    path::{Path, PathBuf},
+};
 
 use config::{Config, ConfigError, Environment, File};
 use primitives::Chain;
@@ -120,12 +124,7 @@ pub fn load_config() -> Result<(NodeConfig, HashMap<Chain, ChainConfig>), Config
 
     let chains = find_chain_files(&base_dir)
         .into_iter()
-        .map(|path| {
-            Config::builder()
-                .add_source(File::from(path))
-                .build()?
-                .try_deserialize::<ChainsFile>()
-        })
+        .map(|path| Config::builder().add_source(File::from(path)).build()?.try_deserialize::<ChainsFile>())
         .collect::<Result<Vec<_>, _>>()?
         .into_iter()
         .flat_map(|cf| cf.chains)
diff --git a/apps/dynode/src/main.rs b/apps/dynode/src/main.rs
@@ -6,9 +6,9 @@ use dynode::config::load_config;
 use dynode::metrics::Metrics;
 use dynode::monitoring::{NodeMonitor, NodeService};
 use dynode::proxy::{ProxyRequestBuilder, ProxyResponse};
-use primitives::Chain;
 use dynode::response::{ErrorResponse, ProxyRocketResponse};
 use gem_tracing::{error_with_fields, info_with_fields};
+use primitives::Chain;
 use reqwest::Method;
 use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use rocket::config::Config;
@@ -83,7 +83,13 @@ async fn root_endpoint() -> &'static str {
     "ok"
 }
 
-async fn process_proxy(chain: Chain, method: Method, request: &Request<'_>, data: Data<'_>, node_service: &NodeService) -> Result<ProxyResponse, ErrorResponse> {
+async fn process_proxy(
+    chain: Chain,
+    method: Method,
+    request: &Request<'_>,
+    data: Data<'_>,
+    node_service: &NodeService,
+) -> Result<ProxyResponse, ErrorResponse> {
     let body = read_request_body(data).await?;
     let headers = build_header_map(request)?;
     let uri = request.uri().to_string();
diff --git a/apps/dynode/src/proxy/proxy_request_builder.rs b/apps/dynode/src/proxy/proxy_request_builder.rs
@@ -12,16 +12,7 @@ impl ProxyRequestBuilder {
         let user_agent = Self::extract_user_agent(&headers);
         let (path, path_with_query) = Self::prepare_paths(&uri);
 
-        Ok(ProxyRequest::new(
-            method,
-            headers,
-            body,
-            path,
-            path_with_query,
-            host,
-            user_agent,
-            chain,
-        ))
+        Ok(ProxyRequest::new(method, headers, body, path, path_with_query, host, user_agent, chain))
     }
 
     fn extract_host(headers: &HeaderMap) -> Result<String, Status> {
@@ -96,5 +87,4 @@ mod tests {
         assert_eq!(ProxyRequestBuilder::parse_hostname("example.com:8080"), "example.com");
         assert_eq!(ProxyRequestBuilder::parse_hostname("localhost:3000"), "localhost");
     }
-
 }
diff --git a/crates/fiat/src/providers/paybis/client.rs b/crates/fiat/src/providers/paybis/client.rs
@@ -1,4 +1,4 @@
-use super::models::{Assets, PaybisData, PaybisQuote, PaybisResponse, PaymentMethodWithLimits, QuoteRequest, Request, RequestResponse};
+use super::models::{Assets, PaybisQuote, PaybisResponse, QuoteRequest, Request, RequestResponse};
 use crate::rsa_signature::generate_rsa_pss_signature;
 use primitives::FiatProviderName;
 use reqwest::Client;
@@ -89,18 +89,6 @@ impl PaybisClient {
             .into()
     }
 
-    pub async fn get_payment_method_limits(&self) -> Result<PaybisData<Vec<PaymentMethodWithLimits>>, Box<dyn std::error::Error + Send + Sync>> {
-        let url = format!("{PAYBIS_API_BASE_URL}/v2/payment-method-list-with-limits");
-        self.client
-            .get(url)
-            .header("Authorization", &self.api_key)
-            .send()
-            .await?
-            .json::<PaybisResponse<PaybisData<Vec<PaymentMethodWithLimits>>>>()
-            .await?
-            .into()
-    }
-
     pub async fn create_request(&self, request_body: Request) -> Result<RequestResponse, Box<dyn std::error::Error + Send + Sync>> {
         let body = serde_json::to_string(&request_body)?;
         let url = format!("{PAYBIS_API_BASE_URL}/v3/request");
@@ -112,7 +100,7 @@ impl PaybisClient {
         wallet_address: &str,
         from_currency: &str,
         to_currency: &str,
-        amount: f64,
+        quote_id: &str,
         is_buy: bool,
         user_ip: &str,
         locale: &str,
@@ -123,7 +111,7 @@ impl PaybisClient {
                 wallet_address.to_owned(),
                 to_currency.to_string(),
                 from_currency.to_string(),
-                amount,
+                quote_id.to_string(),
                 user_ip.to_string(),
                 locale.to_string(),
             )
@@ -133,7 +121,7 @@ impl PaybisClient {
                 wallet_address.to_owned(),
                 to_currency.to_string(),
                 from_currency.to_string(),
-                amount,
+                quote_id.to_string(),
                 user_ip.to_string(),
                 locale.to_string(),
             )
diff --git a/crates/fiat/src/providers/paybis/mapper.rs b/crates/fiat/src/providers/paybis/mapper.rs
@@ -1,16 +1,13 @@
-use std::str::FromStr;
-
 use primitives::currency::Currency;
 use primitives::{AssetId, Chain, FiatProviderName, FiatQuoteType, FiatTransaction, FiatTransactionStatus, PaymentType};
 use streamer::FiatWebhook;
 
 use crate::model::FiatProviderAsset;
-use crate::providers::paybis::models::{PaybisData, PaymentMethodWithLimits};
 use primitives::fiat_assets::FiatAssetLimits;
 
 use super::{
     client::PaybisClient,
-    models::{Currency as PaybisCurrency, PaybisWebhookData},
+    models::{Currency as PaybisCurrency, PaybisData, PaybisWebhookData},
 };
 
 pub fn map_asset_id(currency: PaybisCurrency) -> Option<AssetId> {
@@ -137,7 +134,16 @@ pub fn map_webhook_data(webhook_data: PaybisWebhookData) -> FiatWebhook {
     })
 }
 
-fn map_asset(currency: PaybisCurrency, buy_limits: Vec<FiatAssetLimits>, sell_limits: Vec<FiatAssetLimits>) -> Option<FiatProviderAsset> {
+fn default_buy_limits() -> Vec<FiatAssetLimits> {
+    vec![FiatAssetLimits {
+        currency: Currency::USD,
+        payment_type: PaymentType::Card,
+        min_amount: None,
+        max_amount: None,
+    }]
+}
+
+fn map_asset(currency: PaybisCurrency) -> Option<FiatProviderAsset> {
     if !currency.is_crypto() {
         return None;
     }
@@ -151,52 +157,13 @@ fn map_asset(currency: PaybisCurrency, buy_limits: Vec<FiatAssetLimits>, sell_li
         network: currency.blockchain_name.clone(),
         enabled: true,
         unsupported_countries: Some(currency.unsupported_countries()),
-        buy_limits,
-        sell_limits,
+        buy_limits: default_buy_limits(),
+        sell_limits: vec![],
     })
 }
 
 pub fn map_assets(currencies: Vec<PaybisCurrency>) -> Vec<FiatProviderAsset> {
-    currencies.into_iter().flat_map(|currency| map_asset(currency, vec![], vec![])).collect()
-}
-
-fn map_payment_type(payment_method_name: &str) -> Option<PaymentType> {
-    match payment_method_name {
-        "gem-wallet-credit-card" => Some(PaymentType::Card),
-        "gem-wallet-google-pay-credit-card" => Some(PaymentType::GooglePay),
-        "gem-wallet-apple-pay-credit-card" => Some(PaymentType::ApplePay),
-        _ => None,
-    }
-}
-
-pub fn map_assets_with_limits(currencies: Vec<PaybisCurrency>, limits: &PaybisData<Vec<PaymentMethodWithLimits>>) -> Vec<FiatProviderAsset> {
-    currencies
-        .into_iter()
-        .filter_map(|currency| {
-            let asset_buy_limits = limits
-                .data
-                .iter()
-                .filter_map(|payment_method| map_payment_type(&payment_method.name).map(|payment_type| (payment_method, payment_type)))
-                .flat_map(|(payment_method, payment_type)| {
-                    payment_method.pairs.iter().filter_map({
-                        let value = currency.code.clone();
-                        move |currency_pair| {
-                            currency_pair.to.iter().find(|c| c.currency_code == value).and_then(|currency_limit| {
-                                Currency::from_str(currency_pair.from.as_str()).ok().map(|fiat_currency| FiatAssetLimits {
-                                    currency: fiat_currency,
-                                    payment_type: payment_type.clone(),
-                                    min_amount: Some(currency_limit.min_amount),
-                                    max_amount: Some(currency_limit.max_amount),
-                                })
-                            })
-                        }
-                    })
-                })
-                .collect();
-
-            map_asset(currency, asset_buy_limits, vec![])
-        })
-        .collect()
+    currencies.into_iter().flat_map(map_asset).collect()
 }
 
 #[cfg(test)]
@@ -350,40 +317,13 @@ mod tests {
     }
 
     #[test]
-    fn test_paybis_limits_parsing() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-        let limits: PaybisData<Vec<PaymentMethodWithLimits>> = serde_json::from_str(include_str!("../../../testdata/paybis/assets_with_limits.json"))?;
-
-        let test_currencies = vec![
-            PaybisCurrency {
-                code: "USDT-TRC20".to_string(),
-                blockchain_name: Some("tron".to_string()),
-            },
-            PaybisCurrency {
-                code: "TRX".to_string(),
-                blockchain_name: Some("tron".to_string()),
-            },
-            PaybisCurrency {
-                code: "XRP".to_string(),
-                blockchain_name: Some("xrp".to_string()),
-            },
-        ];
-
-        let mapped_assets = map_assets_with_limits(test_currencies, &limits);
-
-        // Test that assets with limits have expected min/max amounts
-        let usdt_trc20 = mapped_assets.iter().find(|a| a.symbol == "USDT-TRC20").expect("USDT-TRC20 should exist");
-        assert!(!usdt_trc20.buy_limits.is_empty(), "USDT-TRC20 should have buy limits");
-
-        // Find USD limit
-        let usd_limit = usdt_trc20.buy_limits.iter().find(|limit| limit.currency == Currency::USD);
-        assert!(usd_limit.is_some(), "Should have USD limit");
-
-        if let Some(limit) = usd_limit {
-            assert_eq!(limit.min_amount, Some(5.0));
-            assert_eq!(limit.max_amount, Some(20000.0));
-            assert_eq!(limit.payment_type, PaymentType::Card);
-        }
-
-        Ok(())
+    fn test_default_buy_limits() {
+        let limits = default_buy_limits();
+
+        assert_eq!(limits.len(), 1);
+        assert_eq!(limits[0].currency, Currency::USD);
+        assert_eq!(limits[0].payment_type, PaymentType::Card);
+        assert_eq!(limits[0].min_amount, None);
+        assert_eq!(limits[0].max_amount, None);
     }
 }
diff --git a/crates/fiat/src/providers/paybis/models/limits.rs b/crates/fiat/src/providers/paybis/models/limits.rs
@@ -1,5 +1,4 @@
 use serde::{Deserialize, Serialize};
-use serde_serializers::deserialize_f64_from_str;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PaybisData<T> {
@@ -33,26 +32,3 @@ impl PaybisError {
         format!("Paybis API error [{}]: {}", self.code, self.message).into()
     }
 }
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PaymentMethodWithLimits {
-    pub name: String,
-    pub pairs: Vec<CurrencyPair>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CurrencyPair {
-    pub from: String,
-    pub to: Vec<CurrencyLimit>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CurrencyLimit {
-    pub currency: String,
-    #[serde(rename = "currencyCode")]
-    pub currency_code: String,
-    #[serde(rename = "minAmount", deserialize_with = "deserialize_f64_from_str")]
-    pub min_amount: f64,
-    #[serde(rename = "maxAmount", deserialize_with = "deserialize_f64_from_str")]
-    pub max_amount: f64,
-}
diff --git a/crates/fiat/src/providers/paybis/models/request.rs b/crates/fiat/src/providers/paybis/models/request.rs
@@ -14,8 +14,7 @@ pub struct Request {
     pub crypto_wallet_address: CryptoWalletAddress,
     pub currency_code_from: String,
     pub currency_code_to: String,
-    pub requested_amount: f64,
-    pub requested_amount_type: String,
+    pub quote_id: String,
     pub user_ip: String,
     pub locale: String,
 }
@@ -32,7 +31,7 @@ impl Request {
         wallet_address: String,
         crypto_currency: String,
         fiat_currency: String,
-        fiat_amount: f64,
+        quote_id: String,
         user_ip: String,
         locale: String,
     ) -> Self {
@@ -44,8 +43,7 @@ impl Request {
             },
             currency_code_from: fiat_currency,
             currency_code_to: crypto_currency,
-            requested_amount: fiat_amount,
-            requested_amount_type: "from".to_string(),
+            quote_id,
             user_ip,
             locale,
         }
@@ -56,7 +54,7 @@ impl Request {
         wallet_address: String,
         crypto_currency: String,
         fiat_currency: String,
-        crypto_amount: f64,
+        quote_id: String,
         user_ip: String,
         locale: String,
     ) -> Self {
@@ -68,8 +66,7 @@ impl Request {
             },
             currency_code_from: crypto_currency,
             currency_code_to: fiat_currency,
-            requested_amount: crypto_amount,
-            requested_amount_type: "from".to_string(),
+            quote_id,
             user_ip,
             locale,
         }
@@ -90,8 +87,7 @@ mod tests {
             },
             currency_code_from: "USD".to_string(),
             currency_code_to: "SOL".to_string(),
-            requested_amount: 50.0,
-            requested_amount_type: "from".to_string(),
+            quote_id: "test-quote-id".to_string(),
             user_ip: "1.2.3.4".to_string(),
             locale: "en".to_string(),
         };
@@ -104,8 +100,7 @@ mod tests {
         assert_eq!(parsed["cryptoWalletAddress"]["currencyCode"], "SOL");
         assert_eq!(parsed["currencyCodeFrom"], "USD");
         assert_eq!(parsed["currencyCodeTo"], "SOL");
-        assert_eq!(parsed["requestedAmount"], 50.0);
-        assert_eq!(parsed["requestedAmountType"], "from");
+        assert_eq!(parsed["quoteId"], "test-quote-id");
         assert_eq!(parsed["userIp"], "1.2.3.4");
         assert_eq!(parsed["locale"], "en");
     }
diff --git a/crates/fiat/src/providers/paybis/provider.rs b/crates/fiat/src/providers/paybis/provider.rs
diff --git a/crates/primitives/src/testkit/fiat_mock.rs b/crates/primitives/src/testkit/fiat_mock.rs
