banxa: add create-order flow & model cleanup

Add Banxa create-order support and simplify related models and client logic.

- Introduce CreateOrderRequest and CheckoutOrder models and PAYMENT_METHOD_CARD constant (models/create_order.rs).
- Implement BanxaClient::create_buy_order to POST create-order requests and return checkout info; remove build_quote_url and related URL-building logic (client.rs, provider.rs).
- Add BUY_ORDER_TYPE constant and rename/get specific fiat methods to *_buy variants; use PAYMENT_METHOD_CARD in quote calls.
- Remove obsolete Coin type and several order fields (crypto, fiat, crypto_amount, fees, country) and export adjustments (models/asset.rs, models/order.rs, models/mod.rs).
- Update mapper tests to match the simplified Order shape (mapper.rs).
- Minor cleanup: inline HMAC finalize/encode call (hmac_signature.rs).

These changes move the buy-quote flow from generating redirect URLs locally to creating orders via Banxa's API and returning the checkout URL and provider transaction id.

Author: gemcoder21

crates/fiat/src/hmac_signature.rs

@@ -6,9 +6,7 @@ fn generate_hmac_from_bytes(key_bytes: &[u8], message: &str) -> String {
     type HmacSha256 = Hmac<Sha256>;
     let mut mac = HmacSha256::new_from_slice(key_bytes).expect("HMAC can take key of any size");
     mac.update(message.as_bytes());
-    let result = mac.finalize();
-    let signature = result.into_bytes();
-    general_purpose::STANDARD.encode(signature)
+    general_purpose::STANDARD.encode(mac.finalize().into_bytes())
 }
 
 pub fn generate_hmac_signature(secret_key: &str, message: &str) -> String {

crates/fiat/src/providers/banxa/client.rs

@@ -1,15 +1,15 @@
 use std::error::Error;
 
-use primitives::{FiatProviderName, FiatQuoteUrl};
+use primitives::FiatProviderName;
 use reqwest::{
     Client,
     header::{HeaderMap, HeaderValue},
 };
-use url::Url;
 
-use super::models::{Asset, Country, FiatCurrency, ORDER_TYPE_BUY, Order, Quote};
+use super::models::{Asset, CheckoutOrder, Country, CreateOrderRequest, FiatCurrency, Order, PAYMENT_METHOD_CARD, Quote};
 
 const API_URL: &str = "https://api.banxa.com";
+const BUY_ORDER_TYPE: &str = "buy";
 
 pub struct BanxaClient {
     pub client: Client,
@@ -37,11 +37,7 @@ impl BanxaClient {
     }
 
     pub async fn get_assets_buy(&self) -> Result<Vec<Asset>, Box<dyn Error + Send + Sync>> {
-        self.get_assets_by_order_type(ORDER_TYPE_BUY).await
-    }
-
-    async fn get_assets_by_order_type(&self, order_type: &str) -> Result<Vec<Asset>, Box<dyn Error + Send + Sync>> {
-        let url = format!("{API_URL}/{}/v2/crypto/{order_type}", self.merchant_key);
+        let url = format!("{API_URL}/{}/v2/crypto/{BUY_ORDER_TYPE}", self.merchant_key);
         Ok(self.client.get(&url).headers(self.headers()?).send().await?.json().await?)
     }
 
@@ -53,7 +49,7 @@ impl BanxaClient {
     pub async fn get_quote_buy(&self, symbol: &str, chain: &str, fiat_currency: &str, fiat_amount: f64) -> Result<Quote, Box<dyn Error + Send + Sync>> {
         let fiat_amount = fiat_amount.to_string();
         let query = vec![
-            ("paymentMethodId", "debit-credit-card"),
+            ("paymentMethodId", PAYMENT_METHOD_CARD),
             ("crypto", symbol),
             ("blockchain", chain),
             ("fiat", fiat_currency),
@@ -68,24 +64,23 @@ impl BanxaClient {
         Ok(self.client.get(&url).headers(self.headers()?).send().await?.json().await?)
     }
 
-    pub async fn get_fiat_currencies(&self, order_type: &str) -> Result<Vec<FiatCurrency>, Box<dyn Error + Send + Sync>> {
-        let url = format!("{API_URL}/{}/v2/fiats/{order_type}", self.merchant_key);
+    pub async fn get_fiat_currencies_buy(&self) -> Result<Vec<FiatCurrency>, Box<dyn Error + Send + Sync>> {
+        let url = format!("{API_URL}/{}/v2/fiats/{BUY_ORDER_TYPE}", self.merchant_key);
         Ok(self.client.get(&url).headers(self.headers()?).send().await?.json().await?)
     }
 
-    pub fn build_quote_url(&self, amount: f64, fiat_currency: &str, symbol: &str, network: &str, wallet_address: &str) -> Result<FiatQuoteUrl, Box<dyn Error + Send + Sync>> {
-        let mut url = Url::parse(&self.url)?;
-        url.query_pairs_mut()
-            .append_pair("orderType", ORDER_TYPE_BUY)
-            .append_pair("coinType", symbol)
-            .append_pair("blockchain", network)
-            .append_pair("fiatType", fiat_currency)
-            .append_pair("fiatAmount", &amount.to_string())
-            .append_pair("walletAddress", wallet_address);
-
-        Ok(FiatQuoteUrl {
-            redirect_url: url.to_string(),
-            provider_transaction_id: None,
-        })
+    pub async fn create_buy_order(
+        &self,
+        quote_id: String,
+        fiat_amount: f64,
+        fiat_currency: String,
+        symbol: String,
+        network: String,
+        wallet_address: String,
+    ) -> Result<CheckoutOrder, Box<dyn Error + Send + Sync>> {
+        let request = CreateOrderRequest::new(quote_id, symbol, fiat_currency, fiat_amount, network, wallet_address, self.url.clone());
+        let url = format!("{API_URL}/{}/v2/buy", self.merchant_key);
+        let response = self.client.post(&url).headers(self.headers()?).json(&request).send().await?.error_for_status()?;
+        response.json().await.map_err(|e| e.into())
     }
 }

crates/fiat/src/providers/banxa/mapper.rs

@@ -141,7 +141,7 @@ fn map_payment_type(payment_id: &str) -> Option<PaymentType> {
 
 #[cfg(test)]
 mod tests {
-    use crate::providers::banxa::models::{Coin, FiatCurrency, Order};
+    use crate::providers::banxa::models::{FiatCurrency, Order};
     use primitives::currency::Currency;
     use primitives::{FiatTransactionStatus, PaymentType};
 
@@ -166,19 +166,10 @@ mod tests {
             id: "banxa_order_123".to_string(),
             external_order_id: Some("quote_123".to_string()),
             status: "completed".to_string(),
-            crypto: Coin {
-                id: "BTC".to_string(),
-                blockchain: "BTC".to_string(),
-            },
-            fiat: "USD".to_string(),
             fiat_amount: 100.0,
-            crypto_amount: 0.001,
             wallet_address: "bc1qexample".to_string(),
             transaction_hash: Some("tx_hash".to_string()),
-            processing_fee: None,
-            network_fee: None,
             order_type: "BUY".to_string(),
-            country: Some("US".to_string()),
         })
         .unwrap();
 

crates/fiat/src/providers/banxa/models/asset.rs

@@ -1,12 +1,6 @@
 use serde::Deserialize;
 use std::collections::HashMap;
 
-#[derive(Debug, Deserialize, Clone)]
-pub struct Coin {
-    pub id: String,
-    pub blockchain: String,
-}
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct Asset {
     pub id: String,

crates/fiat/src/providers/banxa/models/create_order.rs

@@ -0,0 +1,40 @@
+use serde::{Deserialize, Serialize};
+
+pub const PAYMENT_METHOD_CARD: &str = "debit-credit-card";
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateOrderRequest {
+    pub payment_method_id: String,
+    pub crypto: String,
+    pub blockchain: String,
+    pub fiat: String,
+    pub fiat_amount: String,
+    pub wallet_address: String,
+    pub redirect_url: String,
+    pub external_customer_id: String,
+    pub external_order_id: String,
+}
+
+impl CreateOrderRequest {
+    pub fn new(external_order_id: String, crypto: String, fiat: String, fiat_amount: f64, blockchain: String, wallet_address: String, redirect_url: String) -> Self {
+        Self {
+            payment_method_id: PAYMENT_METHOD_CARD.to_string(),
+            crypto,
+            blockchain,
+            fiat,
+            fiat_amount: fiat_amount.to_string(),
+            external_customer_id: wallet_address.clone(),
+            wallet_address,
+            redirect_url,
+            external_order_id,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CheckoutOrder {
+    pub id: String,
+    pub checkout_url: String,
+}

crates/fiat/src/providers/banxa/models/mod.rs

@@ -1,13 +1,15 @@
 pub mod asset;
 pub mod country;
+pub mod create_order;
 pub mod fiat_currencies;
 pub mod order;
 pub mod quote;
 pub mod webhook;
 
 pub use asset::*;
 pub use country::*;
+pub use create_order::*;
 pub use fiat_currencies::*;
-pub use order::{ORDER_TYPE_BUY, ORDER_TYPE_SELL, Order};
+pub use order::Order;
 pub use quote::*;
 pub use webhook::*;

crates/fiat/src/providers/banxa/models/order.rs

@@ -1,29 +1,15 @@
 use serde::Deserialize;
-use serde_serializers::{deserialize_f64_from_str, deserialize_option_f64_from_str};
-
-use super::asset::Coin;
-
-pub const ORDER_TYPE_BUY: &str = "buy";
-pub const ORDER_TYPE_SELL: &str = "sell";
+use serde_serializers::deserialize_f64_from_str;
 
 #[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Order {
     pub id: String,
     pub external_order_id: Option<String>,
     pub status: String,
-    pub crypto: Coin,
-    pub fiat: String,
     #[serde(deserialize_with = "deserialize_f64_from_str")]
     pub fiat_amount: f64,
-    #[serde(deserialize_with = "deserialize_f64_from_str")]
-    pub crypto_amount: f64,
     pub wallet_address: String,
     pub transaction_hash: Option<String>,
-    #[serde(deserialize_with = "deserialize_option_f64_from_str")]
-    pub processing_fee: Option<f64>,
-    #[serde(deserialize_with = "deserialize_option_f64_from_str")]
-    pub network_fee: Option<f64>,
     pub order_type: String,
-    pub country: Option<String>,
 }

crates/fiat/src/providers/banxa/provider.rs

@@ -18,7 +18,7 @@ impl FiatProvider for BanxaClient {
     }
 
     async fn get_assets(&self) -> Result<Vec<FiatProviderAsset>, Box<dyn std::error::Error + Send + Sync>> {
-        let (assets, buy_fiat_currencies) = tokio::try_join!(self.get_assets_buy(), self.get_fiat_currencies("buy"))?;
+        let (assets, buy_fiat_currencies) = tokio::try_join!(self.get_assets_buy(), self.get_fiat_currencies_buy())?;
         Ok(assets.into_iter().flat_map(|asset| map_asset_with_limits(asset, &buy_fiat_currencies, &[])).collect())
     }
 
@@ -60,7 +60,21 @@ impl FiatProvider for BanxaClient {
         match data.quote.quote_type {
             FiatQuoteType::Buy => {
                 let network = FiatMapping::get_network(data.asset_symbol.network)?;
-                self.build_quote_url(data.quote.fiat_amount, &data.quote.fiat_currency, &data.asset_symbol.symbol, &network, &data.wallet_address)
+                let order = self
+                    .create_buy_order(
+                        data.quote.id,
+                        data.quote.fiat_amount,
+                        data.quote.fiat_currency,
+                        data.asset_symbol.symbol,
+                        network,
+                        data.wallet_address,
+                    )
+                    .await?;
+
+                Ok(FiatQuoteUrl {
+                    redirect_url: order.checkout_url,
+                    provider_transaction_id: Some(order.id),
+                })
             }
             FiatQuoteType::Sell => Err("not supported".into()),
         }