use std::fmt;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{Map, Value};
use crate::Decimal;
#[cfg(feature = "client")]
use crate::{decimal::is_plain_decimal, Error};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PaymentStatus {
Created,
Locked,
Pending,
Detected,
Confirming,
Confirmed,
Settling,
Completed,
Expired,
Failed,
Flagged,
NeedsReview,
Orphaned,
Cancelled,
Other(String),
}
impl PaymentStatus {
pub const ALL: [PaymentStatus; 14] = [
PaymentStatus::Created,
PaymentStatus::Locked,
PaymentStatus::Pending,
PaymentStatus::Detected,
PaymentStatus::Confirming,
PaymentStatus::Confirmed,
PaymentStatus::Settling,
PaymentStatus::Completed,
PaymentStatus::Expired,
PaymentStatus::Failed,
PaymentStatus::Flagged,
PaymentStatus::NeedsReview,
PaymentStatus::Orphaned,
PaymentStatus::Cancelled,
];
pub fn as_str(&self) -> &str {
match self {
PaymentStatus::Created => "created",
PaymentStatus::Locked => "locked",
PaymentStatus::Pending => "pending",
PaymentStatus::Detected => "detected",
PaymentStatus::Confirming => "confirming",
PaymentStatus::Confirmed => "confirmed",
PaymentStatus::Settling => "settling",
PaymentStatus::Completed => "completed",
PaymentStatus::Expired => "expired",
PaymentStatus::Failed => "failed",
PaymentStatus::Flagged => "flagged",
PaymentStatus::NeedsReview => "needs_review",
PaymentStatus::Orphaned => "orphaned",
PaymentStatus::Cancelled => "cancelled",
PaymentStatus::Other(s) => s,
}
}
pub fn parse(value: &str) -> Self {
PaymentStatus::ALL
.iter()
.find(|s| s.as_str() == value)
.cloned()
.unwrap_or_else(|| PaymentStatus::Other(value.to_string()))
}
pub fn is_known(&self) -> bool {
!matches!(self, PaymentStatus::Other(_))
}
}
impl fmt::Display for PaymentStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl Serialize for PaymentStatus {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> Deserialize<'de> for PaymentStatus {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
Ok(PaymentStatus::parse(&String::deserialize(deserializer)?))
}
}
fn digits<'de, D: Deserializer<'de>>(deserializer: D) -> Result<String, D::Error> {
let value = String::deserialize(deserializer)?;
if !value.is_empty() && value.bytes().all(|b| b.is_ascii_digit()) {
Ok(value)
} else {
Err(serde::de::Error::custom(format!(
"expected a string of digits, got {value:?}"
)))
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreatePaymentParams {
pub amount: Decimal,
pub crypto_type: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idempotency_key: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub order_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub guest_session_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<Map<String, Value>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub callback_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub redirect_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fiat_currency: Option<String>,
}
impl CreatePaymentParams {
pub fn new(amount: Decimal, crypto_type: impl Into<String>) -> Self {
CreatePaymentParams {
amount,
crypto_type: crypto_type.into(),
idempotency_key: None,
description: None,
order_id: None,
customer_id: None,
guest_session_id: None,
metadata: None,
callback_url: None,
redirect_url: None,
fiat_currency: None,
}
}
pub fn idempotency_key(mut self, key: impl Into<String>) -> Self {
self.idempotency_key = Some(key.into());
self
}
pub fn order_id(mut self, order_id: impl Into<String>) -> Self {
self.order_id = Some(order_id.into());
self
}
pub fn description(mut self, description: impl Into<String>) -> Self {
self.description = Some(description.into());
self
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPaymentsParams {
#[serde(default)]
pub page: Option<u32>,
#[serde(default)]
pub limit: Option<u32>,
#[serde(default)]
pub status: Option<PaymentStatus>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PayoutParams {
pub amount: Decimal,
pub idempotency_key: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub settlement_method: Option<String>,
}
impl PayoutParams {
pub fn new(amount: Decimal, idempotency_key: impl Into<String>) -> Self {
PayoutParams {
amount,
idempotency_key: idempotency_key.into(),
settlement_method: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateWebhookConfigParams {
pub url: String,
pub events: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreatePaymentLinkParams {
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub slug: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub preset_amount_ghs: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub preset_crypto_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_cryptos: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub note_for_customer: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreatedPayment {
pub id: String,
pub environment: String,
pub session_code: String,
pub status: PaymentStatus,
pub amount_ghs: Decimal,
pub crypto_type: String,
pub crypto_amount: Decimal,
pub locked_rate: Decimal,
pub deposit_address: String,
pub chain_type: String,
pub network: String,
pub qr_code_data: String,
pub expires_at: String,
pub expires_in_seconds: i64,
pub merchant_id: String,
pub created_at: String,
pub quote_id: String,
pub rate_locked_at: String,
pub rate_expires_at: String,
pub token_decimals: i64,
#[serde(default)]
pub token_contract: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PaymentEconomics {
pub policy_version: String,
pub invoice_ghs: Decimal,
pub received_value_ghs: Decimal,
pub recognized_gross_ghs: Decimal,
pub merchant_discount_ghs: Decimal,
pub surplus_ghs: Decimal,
pub fee_ghs: Decimal,
pub merchant_net_ghs: Decimal,
#[serde(default)]
pub discount_authority: Option<String>,
#[serde(default)]
pub approved_by: Option<String>,
#[serde(default)]
pub approval_reason: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PaymentPricingTerms {
pub policy_version: String,
pub invoice_ghs: Decimal,
pub locked_rate: Decimal,
pub fee_percent: Decimal,
pub spread_bps: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PaymentOrderTerms {
#[serde(default)]
pub order_id: Option<String>,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub redirect_url: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PayoutView {
pub tone: String,
pub headline: String,
pub detail: String,
#[serde(default)]
pub settlement_id: Option<String>,
#[serde(default)]
pub settlement_status: Option<String>,
#[serde(default)]
pub settlement_method: Option<String>,
#[serde(default)]
pub support_contact: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Payment {
pub id: String,
pub environment: String,
pub merchant_id: String,
pub session_code: String,
pub status: PaymentStatus,
pub amount_ghs: Decimal,
pub crypto_amount: Decimal,
pub locked_rate: Decimal,
#[serde(default)]
pub fiat_currency: Option<String>,
#[serde(default)]
pub crypto_type: Option<String>,
#[serde(default)]
pub chain_type: Option<String>,
#[serde(default)]
pub network: Option<String>,
#[serde(default)]
pub deposit_address: Option<String>,
#[serde(default)]
pub qr_code_data: Option<String>,
#[serde(default)]
pub token_contract: Option<String>,
#[serde(default)]
pub token_decimals: Option<i64>,
#[serde(default)]
pub quote_id: Option<String>,
#[serde(default)]
pub rate_locked_at: Option<String>,
#[serde(default)]
pub rate_expires_at: Option<String>,
#[serde(default)]
pub risk_status: Option<String>,
#[serde(default)]
pub tx_hash: Option<String>,
#[serde(default)]
pub confirmations_required: Option<i64>,
#[serde(default)]
pub confirmations_received: Option<i64>,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub metadata: Option<Map<String, Value>>,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub updated_at: Option<String>,
#[serde(default)]
pub completed_at: Option<String>,
#[serde(default)]
pub expires_at: Option<String>,
#[serde(default)]
pub economics: Option<PaymentEconomics>,
#[serde(default)]
pub pricing_terms: Option<PaymentPricingTerms>,
#[serde(default)]
pub order_terms: Option<PaymentOrderTerms>,
#[serde(default)]
pub payout: Option<PayoutView>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PaymentSummary {
pub id: String,
pub environment: String,
pub merchant_id: String,
pub status: PaymentStatus,
pub amount_fiat: Decimal,
pub currency: String,
pub crypto_amount: Decimal,
pub crypto_type: String,
pub deposit_address: String,
pub rate_locked: Decimal,
pub created_at: String,
#[serde(default)]
pub recognized_amount_fiat: Option<Decimal>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PaymentList {
pub payments: Vec<PaymentSummary>,
pub total: i64,
pub page: i64,
pub limit: i64,
pub total_pages: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PayoutResponse {
pub status: String,
pub settlement_method: String,
pub message: String,
#[serde(default)]
pub replayed: Option<bool>,
#[serde(default)]
pub id: Option<String>,
#[serde(default)]
pub amount: Option<Decimal>,
#[serde(default)]
pub currency: Option<String>,
#[serde(default)]
pub created_at: Option<String>,
#[serde(default)]
pub settlements: Option<Vec<Map<String, Value>>>,
#[serde(default)]
pub fill_id: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExchangeRate {
pub crypto_type: String,
pub fiat_currency: String,
pub rate: Decimal,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssetBalance {
pub currency: String,
pub cleared: Decimal,
pub reserved: Decimal,
pub available: Decimal,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnallocatedBucket {
pub asset: String,
pub count: i64,
#[serde(deserialize_with = "digits")]
pub total_amount_smallest: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnallocatedBuckets {
pub dust: Vec<UnallocatedBucket>,
pub excess: Vec<UnallocatedBucket>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Balances {
pub merchant_id: String,
pub environment: String,
pub settlement_preference: String,
pub ghs_available_exact: Decimal,
pub ghs_cleared_exact: Decimal,
pub ghs_reserved_exact: Decimal,
pub usdt_treasury_exact: Decimal,
pub usdt_available_exact: Decimal,
pub usdt_cleared_exact: Decimal,
pub usdt_reserved_exact: Decimal,
#[serde(default)]
pub ghs_available: Option<f64>,
#[serde(default)]
pub ghs_cleared: Option<f64>,
#[serde(default)]
pub ghs_reserved: Option<f64>,
#[serde(default)]
pub usdt_treasury: Option<f64>,
#[serde(default)]
pub usdt_available: Option<f64>,
#[serde(default)]
pub usdt_cleared: Option<f64>,
#[serde(default)]
pub usdt_reserved: Option<f64>,
#[serde(default)]
pub currencies: Option<std::collections::BTreeMap<String, Decimal>>,
#[serde(default)]
pub asset_balances: Option<Vec<AssetBalance>>,
#[serde(default)]
pub unallocated_buckets: Option<UnallocatedBuckets>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebhookEndpoint {
pub id: String,
pub url: String,
pub events: Vec<String>,
pub enabled: bool,
pub secret_version: i64,
pub sequence: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebhookConfig {
pub url: String,
pub events: Vec<String>,
pub enabled: bool,
#[serde(default)]
pub secret: Option<String>,
#[serde(default)]
pub secret_version: Option<i64>,
#[serde(default)]
pub webhooks: Option<Vec<WebhookEndpoint>>,
#[serde(default)]
pub message: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RotatedWebhookSecret {
pub message: String,
pub webhook_id: String,
pub secret: String,
pub secret_version: i64,
pub previous_secret_grace_hours: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PaymentLink {
pub id: String,
pub merchant_id: String,
pub name: String,
pub is_active: bool,
pub created_at: String,
#[serde(default)]
pub slug: Option<String>,
#[serde(default)]
pub preset_amount_ghs: Option<f64>,
#[serde(default)]
pub preset_crypto_type: Option<String>,
#[serde(default)]
pub allowed_cryptos: Option<Vec<String>>,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub note_for_customer: Option<String>,
#[serde(default)]
pub link_views: Option<i64>,
#[serde(default)]
pub link_payments: Option<i64>,
#[serde(default)]
pub total_amount_received: Option<f64>,
#[serde(default)]
pub statistics_scope: Option<String>,
#[serde(default)]
pub last_payment_at: Option<String>,
#[serde(default)]
pub updated_at: Option<String>,
}
#[cfg(feature = "client")]
#[derive(Deserialize)]
pub(crate) struct PaymentLinks {
pub payment_links: Vec<PaymentLink>,
}
#[cfg(feature = "client")]
pub(crate) fn parse_rates(raw: &Value) -> Result<Vec<ExchangeRate>, Error> {
let doc = raw
.as_object()
.ok_or_else(|| Error::schema("expected an object for the rates response"))?;
let assets = match doc.get("ASSETS").or_else(|| doc.get("assets")) {
None => return Ok(Vec::new()),
Some(v) => v
.as_object()
.ok_or_else(|| Error::schema("rates.assets must be an object"))?,
};
let mut out = Vec::new();
for (symbol, legs) in assets {
let Some(legs) = legs.as_object() else {
continue;
};
for (fiat, rate) in legs {
let text = match rate {
Value::String(s) if is_plain_decimal(s) => s.clone(),
Value::Number(n) => number_text(n).ok_or_else(|| {
Error::schema(format!("rates.{symbol}.{fiat} must be a decimal"))
})?,
_ => {
return Err(Error::schema(format!(
"rates.{symbol}.{fiat} must be a decimal"
)))
}
};
out.push(ExchangeRate {
crypto_type: symbol.clone(),
fiat_currency: fiat.clone(),
rate: Decimal::from_trusted(text),
});
}
}
out.sort_by(|a, b| {
a.crypto_type
.cmp(&b.crypto_type)
.then_with(|| a.fiat_currency.cmp(&b.fiat_currency))
});
Ok(out)
}
#[cfg(feature = "client")]
fn number_text(n: &serde_json::Number) -> Option<String> {
if let Some(i) = n.as_i64() {
return Some(i.to_string());
}
if let Some(u) = n.as_u64() {
return Some(u.to_string());
}
let f = n.as_f64()?;
if !f.is_finite() {
return None;
}
let text = format!("{f}");
if is_plain_decimal(&text) {
Some(text)
} else {
None
}
}