sagapay_sdk/

client.rs

use reqwest::header::{HeaderMap, HeaderValue, ACCEPT, CONTENT_TYPE};
use reqwest::Client as ReqwestClient;
use serde::{de::DeserializeOwned, Serialize};
use std::sync::Arc;

use crate::config::Config;
use crate::error::Error;
use crate::models::{
    CreateDepositParams, CreateWithdrawalParams, DepositResponse, TransactionStatusResponse,
    TransactionType, WalletBalanceResponse, WithdrawalResponse,
};

/// SagaPay API client
#[derive(Debug, Clone)]
pub struct Client {
    config: Arc<Config>,
    http_client: ReqwestClient,
}

impl Client {
    /// Create a new SagaPay client
    pub fn new(config: Config) -> Self {
        let http_client = ReqwestClient::builder()
            .timeout(std::time::Duration::from_secs(30))
            .build()
            .expect("Failed to create HTTP client");

        Self {
            config: Arc::new(config),
            http_client,
        }
    }

    /// Create a deposit address
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sagapay::{Client, Config, CreateDepositParams, NetworkType};
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), sagapay::Error> {
    ///     let client = Client::new(Config {
    ///         api_key: "your-api-key".to_string(),
    ///         api_secret: "your-api-secret".to_string(),
    ///         ..Config::default()
    ///     });
    ///
    ///     let deposit = client.create_deposit(CreateDepositParams {
    ///         network_type: NetworkType::BEP20,
    ///         contract_address: "0".to_string(),
    ///         amount: "1.5".to_string(),
    ///         ipn_url: "https://example.com/webhook".to_string(),
    ///         udf: Some("order-123".to_string()),
    ///         address_type: Some("TEMPORARY".to_string()),
    ///     }).await?;
    ///
    ///     println!("Deposit address: {}", deposit.address);
    ///     Ok(())
    /// }
    /// ```
    pub async fn create_deposit(
        &self,
        params: CreateDepositParams,
    ) -> Result<DepositResponse, Error> {
        self.post("/create-deposit", &params).await
    }

    /// Create a withdrawal
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sagapay::{Client, Config, CreateWithdrawalParams, NetworkType};
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), sagapay::Error> {
    ///     let client = Client::new(Config {
    ///         api_key: "your-api-key".to_string(),
    ///         api_secret: "your-api-secret".to_string(),
    ///         ..Config::default()
    ///     });
    ///
    ///     let withdrawal = client.create_withdrawal(CreateWithdrawalParams {
    ///         network_type: NetworkType::ERC20,
    ///         contract_address: "0xdAC17F958D2ee523a2206206994597C13D831ec7".to_string(), // USDT
    ///         address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e".to_string(),
    ///         amount: "10.5".to_string(),
    ///         ipn_url: "https://example.com/webhook".to_string(),
    ///         udf: Some("withdrawal-456".to_string()),
    ///     }).await?;
    ///
    ///     println!("Withdrawal ID: {}", withdrawal.id);
    ///     Ok(())
    /// }
    /// ```
    pub async fn create_withdrawal(
        &self,
        params: CreateWithdrawalParams,
    ) -> Result<WithdrawalResponse, Error> {
        self.post("/create-withdrawal", &params).await
    }

    /// Check transaction status
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sagapay::{Client, Config, TransactionType};
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), sagapay::Error> {
    ///     let client = Client::new(Config {
    ///         api_key: "your-api-key".to_string(),
    ///         api_secret: "your-api-secret".to_string(),
    ///         ..Config::default()
    ///     });
    ///
    ///     let address = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
    ///     let tx_type = TransactionType::Deposit;
    ///     
    ///     let status = client.check_transaction_status(address, tx_type).await?;
    ///     
    ///     println!("Transaction count: {}", status.count);
    ///     for tx in status.transactions {
    ///         println!("ID: {}, Status: {:?}, Amount: {}", tx.id, tx.status, tx.amount);
    ///     }
    ///     
    ///     Ok(())
    /// }
    /// ```
    pub async fn check_transaction_status(
        &self,
        address: &str,
        transaction_type: TransactionType,
    ) -> Result<TransactionStatusResponse, Error> {
        let tx_type = match transaction_type {
            TransactionType::Deposit => "deposit",
            TransactionType::Withdrawal => "withdrawal",
        };

        let params = [("address", address), ("type", tx_type)];

        self.get_with_query("/check-transaction-status", &params)
            .await
    }

    /// Fetch wallet balance
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sagapay::{Client, Config, NetworkType};
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), sagapay::Error> {
    ///     let client = Client::new(Config {
    ///         api_key: "your-api-key".to_string(),
    ///         api_secret: "your-api-secret".to_string(),
    ///         ..Config::default()
    ///     });
    ///
    ///     let address = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
    ///     let network_type = NetworkType::ERC20;
    ///     let contract_address = "0xdAC17F958D2ee523a2206206994597C13D831ec7"; // USDT
    ///     
    ///     let balance = client.fetch_wallet_balance(address, network_type, contract_address).await?;
    ///     
    ///     println!("Token: {} ({})", balance.token.symbol, balance.token.name);
    ///     println!("Balance: {}", balance.balance.formatted);
    ///     
    ///     Ok(())
    /// }
    /// ```
    pub async fn fetch_wallet_balance(
        &self,
        address: &str,
        network_type: crate::models::NetworkType,
        contract_address: &str,
    ) -> Result<WalletBalanceResponse, Error> {
        let params = [
            ("address", address),
            ("networkType", &network_type.to_string()),
            ("contractAddress", contract_address),
        ];

        self.get_with_query("/fetch-wallet-balance", &params).await
    }

    /// Get the client's API key
    pub fn api_key(&self) -> &str {
        &self.config.api_key
    }

    /// Get the client's API secret
    pub fn api_secret(&self) -> &str {
        &self.config.api_secret
    }

    /// Make a GET request
    async fn get<T: DeserializeOwned>(&self, path: &str) -> Result<T, Error> {
        let url = format!("{}{}", self.config.base_url, path);
        let headers = self.build_headers()?;

        let response = self.http_client.get(&url).headers(headers).send().await?;

        self.handle_response(response).await
    }

    /// Make a GET request with query parameters
    async fn get_with_query<T: DeserializeOwned, Q: Serialize + ?Sized>(
        &self,
        path: &str,
        query: &Q,
    ) -> Result<T, Error> {
        let url = format!("{}{}", self.config.base_url, path);
        let headers = self.build_headers()?;

        let response = self
            .http_client
            .get(&url)
            .headers(headers)
            .query(query)
            .send()
            .await?;

        self.handle_response(response).await
    }

    /// Make a POST request
    async fn post<T: DeserializeOwned, D: Serialize + ?Sized>(
        &self,
        path: &str,
        data: &D,
    ) -> Result<T, Error> {
        let url = format!("{}{}", self.config.base_url, path);
        let headers = self.build_headers()?;

        let response = self
            .http_client
            .post(&url)
            .headers(headers)
            .json(data)
            .send()
            .await?;

        self.handle_response(response).await
    }

    /// Build common headers for requests
    fn build_headers(&self) -> Result<HeaderMap, Error> {
        let mut headers = HeaderMap::new();

        headers.insert(
            "x-api-key",
            HeaderValue::from_str(&self.config.api_key).map_err(|e| Error::Other(e.to_string()))?,
        );
        headers.insert(
            "x-api-secret",
            HeaderValue::from_str(&self.config.api_secret)
                .map_err(|e| Error::Other(e.to_string()))?,
        );
        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
        headers.insert(ACCEPT, HeaderValue::from_static("application/json"));

        Ok(headers)
    }

    /// Handle API response
    async fn handle_response<T: DeserializeOwned>(
        &self,
        response: reqwest::Response,
    ) -> Result<T, Error> {
        let status = response.status();
        let body = response.text().await?;

        if !status.is_success() {
            let error_response: serde_json::Value = match serde_json::from_str(&body) {
                Ok(json) => json,
                Err(_) => {
                    return Err(Error::ApiError {
                        status_code: status.as_u16(),
                        message: body,
                        error_code: None,
                    });
                }
            };

            let message = error_response
                .get("message")
                .and_then(|m| m.as_str())
                .unwrap_or("Unknown error")
                .to_string();

            let error_code = error_response
                .get("error")
                .and_then(|e| e.as_str())
                .map(|s| s.to_string());

            return Err(Error::ApiError {
                status_code: status.as_u16(),
                message,
                error_code,
            });
        }

        match serde_json::from_str(&body) {
            Ok(data) => Ok(data),
            Err(e) => Err(Error::JsonError(e)),
        }
    }
}