Struct Client

Source

pub struct Client { /* private fields */ }

Expand description

SagaPay API client

Implementations§

Source §

impl Client

Source

pub fn new(config: Config) -> Self

Create a new SagaPay client

Source

pub async fn create_deposit( &self, params: CreateDepositParams, ) -> Result<DepositResponse, Error>

Create a deposit address

§Example

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(())
}

Source

pub async fn create_withdrawal( &self, params: CreateWithdrawalParams, ) -> Result<WithdrawalResponse, Error>

Create a withdrawal

§Example

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(())
}

Source

pub async fn check_transaction_status( &self, address: &str, transaction_type: TransactionType, ) -> Result<TransactionStatusResponse, Error>

Check transaction status

§Example

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(())
}

Source

pub async fn fetch_wallet_balance( &self, address: &str, network_type: NetworkType, contract_address: &str, ) -> Result<WalletBalanceResponse, Error>

Fetch wallet balance

§Example

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(())
}