#![allow(clippy::doc_markdown, clippy::too_many_arguments)]
use std::collections::BTreeMap;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use crate::amount::Amount;
use crate::error::ErrorBody;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AccountId {
pub user_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ApiKey {
#[serde(default)]
pub allowed_ips: Vec<String>,
pub created_at: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires_at: Option<DateTime<Utc>>,
pub id: String,
pub key_id: String,
pub label: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_used_at: Option<DateTime<Utc>>,
pub rate_tier: String,
pub revoked: bool,
#[serde(default)]
pub scopes: Vec<ApiScope>,
}
open_enum! {
ApiScope {
Read => "read",
Trade => "trade",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssetNetwork {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub contract_address: Option<String>,
pub deposit_confirmations: i32,
pub deposit_enabled: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub maintenance: Option<MaintenanceState>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_withdrawal: Option<Amount>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memo_label: Option<String>,
pub memo_required: bool,
pub memo_supported: bool,
pub min_deposit: Amount,
pub min_withdrawal: Amount,
pub network: String,
pub network_name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub notice: Option<String>,
pub token_kind: String,
pub withdrawal_decimals: i32,
pub withdrawal_enabled: bool,
pub withdrawal_fee: Amount,
pub withdrawal_fee_asset: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Asset {
pub decimals: i32,
pub display_decimals: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub icon_key: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub logo_url: Option<String>,
pub max_price_age_secs: i64,
pub name: String,
#[serde(default)]
pub networks: Vec<AssetNetwork>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub notice: Option<String>,
pub symbol: String,
pub trading_enabled: bool,
pub usd_price: Amount,
pub usd_price_stale: bool,
pub usd_price_updated_at: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub website_url: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Balance {
pub asset: String,
pub available: Amount,
#[serde(default)]
pub held_incoming: Vec<HeldIncoming>,
pub locked: Amount,
pub pending: Amount,
#[serde(default)]
pub sequence: i64,
pub total: Amount,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BatchOrderItem {
pub client_order_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub price: Option<Amount>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quantity: Option<Amount>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quote_quantity: Option<Amount>,
pub side: OrderSide,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stop_price: Option<Amount>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub time_in_force: Option<TimeInForce>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trigger_direction: Option<TriggerDirection>,
pub r#type: OrderType,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BatchOrderRequest {
#[serde(default)]
pub orders: Vec<BatchOrderItem>,
pub symbol: String,
}
impl BatchOrderRequest {
pub fn new(symbol: impl Into<String>) -> Self {
Self {
symbol: symbol.into(),
orders: Default::default(),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BatchOrder {
pub failed: i64,
pub placed: i64,
#[serde(default)]
pub results: Vec<BatchOrderResult>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BatchOrderResult {
pub client_order_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorBody>,
#[serde(default)]
pub fills: Vec<Fill>,
pub index: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub order: Option<Order>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelAllAfterRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub symbol: Option<String>,
pub timeout_ms: i64,
}
impl CancelAllAfterRequest {
pub fn new(timeout_ms: i64) -> Self {
Self {
timeout_ms,
symbol: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelAllAfter {
pub armed: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deadline: Option<DateTime<Utc>>,
pub server_time: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub symbol: Option<String>,
pub timeout_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct CancelAllRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub symbol: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelAllResult {
#[serde(default)]
pub already_closed: Vec<String>,
#[serde(default)]
pub cancelled: Vec<String>,
#[serde(default)]
pub failed: Vec<String>,
#[serde(default)]
pub failures: Vec<CancelFailure>,
pub has_more: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelBatchItem {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_order_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub order_id: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelBatchRequest {
#[serde(default)]
pub orders: Vec<CancelBatchItem>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelBatch {
pub cancelled: i64,
pub failed: i64,
#[serde(default)]
pub results: Vec<CancelBatchResult>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelBatchResult {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_order_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorBody>,
pub index: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub order: Option<Order>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub order_id: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CancelFailure {
pub code: String,
pub message: String,
pub order_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesCandle {
pub close: Amount,
pub close_time: i64,
pub high: Amount,
pub low: Amount,
pub open: Amount,
pub open_time: i64,
pub trades: i64,
pub volume: Amount,
}
open_enum! {
CandleInterval {
M1 => "1m",
M5 => "5m",
M15 => "15m",
M30 => "30m",
H1 => "1h",
H4 => "4h",
D1 => "1d",
W1 => "1w",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Candle {
pub close: Amount,
pub high: Amount,
pub low: Amount,
pub open: Amount,
pub open_time: DateTime<Utc>,
pub quote_volume: Amount,
pub trade_count: i64,
pub volume: Amount,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DepositAddress {
pub address: String,
pub asset: String,
pub created_at: DateTime<Utc>,
pub deposit_confirmations: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memo: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memo_label: Option<String>,
pub min_deposit: Amount,
pub network: String,
}
pub type DepositId = String;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Deposit {
pub address: String,
pub amount: Amount,
pub asset: String,
pub confirmations: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub credited_at: Option<DateTime<Utc>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub explorer_url: Option<String>,
pub first_seen_at: DateTime<Utc>,
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memo: Option<String>,
pub network: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub note: Option<String>,
pub output_index: i32,
pub required_confirmations: i32,
pub status: DepositStatus,
pub txid: String,
}
open_enum! {
DepositStatus {
Detected => "detected",
Credited => "credited",
Reversed => "reversed",
Orphaned => "orphaned",
BelowMinimum => "below_minimum",
UnderReview => "under_review",
Internal => "internal",
}
}
open_enum! {
ErrorCode {
ValidationFailed => "VALIDATION_FAILED",
MalformedRequest => "MALFORMED_REQUEST",
InvalidCursor => "INVALID_CURSOR",
PrecisionExceeded => "PRECISION_EXCEEDED",
BelowMinimum => "BELOW_MINIMUM",
AboveMaximum => "ABOVE_MAXIMUM",
InvalidAddress => "INVALID_ADDRESS",
MemoRequired => "MEMO_REQUIRED",
Unauthenticated => "UNAUTHENTICATED",
InvalidCredentials => "INVALID_CREDENTIALS",
TokenExpired => "TOKEN_EXPIRED",
SessionRevoked => "SESSION_REVOKED",
TwoFactorRequired => "TWO_FACTOR_REQUIRED",
TwoFactorInvalid => "TWO_FACTOR_INVALID",
FreshTwoFactorRequired => "FRESH_TWO_FACTOR_REQUIRED",
Forbidden => "FORBIDDEN",
ApiKeyNotAllowed => "API_KEY_NOT_ALLOWED",
KeyNotSignable => "KEY_NOT_SIGNABLE",
SignatureExpired => "SIGNATURE_EXPIRED",
NonceReused => "NONCE_REUSED",
SignatureRequired => "SIGNATURE_REQUIRED",
FuturesRestricted => "FUTURES_RESTRICTED",
AccountFrozen => "ACCOUNT_FROZEN",
AccountOnHold => "ACCOUNT_ON_HOLD",
EmailNotVerified => "EMAIL_NOT_VERIFIED",
RegionBlocked => "REGION_BLOCKED",
JurisdictionBlocked => "JURISDICTION_BLOCKED",
NotFound => "NOT_FOUND",
MethodNotAllowed => "METHOD_NOT_ALLOWED",
AlreadyExists => "ALREADY_EXISTS",
InvalidState => "INVALID_STATE",
IdempotencyKeyConflict => "IDEMPOTENCY_KEY_CONFLICT",
WindowOpen => "WINDOW_OPEN",
EvidenceContradicts => "EVIDENCE_CONTRADICTS",
AmountMismatch => "AMOUNT_MISMATCH",
ConcurrentModification => "CONCURRENT_MODIFICATION",
DeadManNotArmed => "DEAD_MAN_NOT_ARMED",
InsufficientFunds => "INSUFFICIENT_FUNDS",
InsufficientFeeFunds => "INSUFFICIENT_FEE_FUNDS",
MarketUnavailable => "MARKET_UNAVAILABLE",
DepositDisabled => "DEPOSIT_DISABLED",
WithdrawalDisabled => "WITHDRAWAL_DISABLED",
SelfTradeBlocked => "SELF_TRADE_BLOCKED",
LimitExceeded => "LIMIT_EXCEEDED",
PriceUnavailable => "PRICE_UNAVAILABLE",
RateLimited => "RATE_LIMITED",
Internal => "INTERNAL",
ServiceUnavailable => "SERVICE_UNAVAILABLE",
UnderMaintenance => "UNDER_MAINTENANCE",
EngineOverloaded => "ENGINE_OVERLOADED",
UnexpectedRedirect => "UNEXPECTED_REDIRECT",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExchangeConfig {
#[serde(default)]
pub candle_intervals: Vec<CandleInterval>,
pub default_page_size: i32,
pub email_verification_required: bool,
#[serde(default)]
pub features: BTreeMap<String, bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub maintenance_message: Option<String>,
pub maintenance_mode: bool,
pub max_page_size: i32,
pub name: String,
pub password_rules: PasswordRules,
pub registration_enabled: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub support_url: Option<String>,
pub two_factor_freshness_seconds: i64,
pub websocket_path: String,
pub websocket_protocol_version: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExitPoolRequest {
pub shares: Amount,
}
impl ExitPoolRequest {
pub fn new(shares: Amount) -> Self {
Self { shares }
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExitPoolResult {
pub base_returned: Amount,
pub quote_returned: Amount,
pub shares_burned: Amount,
pub shares_held: Amount,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FeeSchedule {
pub label: String,
pub maker_fee_percent: String,
pub min_30d_volume_usd: Amount,
pub taker_fee_percent: String,
pub tier: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesFill {
pub closed_pnl: Amount,
pub coin: String,
pub direction: String,
pub id: String,
pub order_id: String,
pub price: Amount,
pub side: String,
pub size: Amount,
pub taker: bool,
pub time: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Fill {
pub fee: Amount,
pub fee_asset: String,
pub order_id: String,
pub price: Amount,
pub quantity: Amount,
pub quote_quantity: Amount,
pub role: LiquidityRole,
pub side: OrderSide,
pub symbol: String,
pub timestamp: DateTime<Utc>,
pub trade_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Funding {
pub amount: Amount,
pub coin: String,
pub position_size: Amount,
pub rate: Amount,
pub time: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesBook {
pub as_of: DateTime<Utc>,
#[serde(default)]
pub asks: Vec<Level>,
#[serde(default)]
pub bids: Vec<Level>,
pub coin: String,
pub stale: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesCandles {
pub as_of: DateTime<Utc>,
#[serde(default)]
pub candles: Vec<FuturesCandle>,
pub coin: String,
pub interval: String,
pub stale: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesFills {
#[serde(default)]
pub fills: Vec<FuturesFill>,
pub has_account: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub next_cursor: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesFunding {
#[serde(default)]
pub funding: Vec<Funding>,
pub has_account: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub next_cursor: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesMarket {
pub as_of: DateTime<Utc>,
pub market: PerpMarket,
pub stale: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesMarkets {
pub as_of: DateTime<Utc>,
#[serde(default)]
pub markets: Vec<PerpMarket>,
pub stale: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesOpenOrders {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub as_of: Option<DateTime<Utc>>,
pub has_account: bool,
#[serde(default)]
pub orders: Vec<OpenOrder>,
pub stale: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesPositions {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub as_of: Option<DateTime<Utc>>,
pub has_account: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub positions: Option<Positions>,
pub stale: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesTrades {
pub coin: String,
pub stale: bool,
#[serde(default)]
pub trades: Vec<FuturesPublicTrade>,
}
pub type FuturesTransferId = String;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HeldIncoming {
pub amount: Amount,
pub available_at: DateTime<Utc>,
pub transfer_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JoinPoolRequest {
pub base_amount: Amount,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_ratio_deviation_percent: Option<Amount>,
pub quote_amount: Amount,
}
impl JoinPoolRequest {
pub fn new(base_amount: Amount, quote_amount: Amount) -> Self {
Self {
base_amount,
quote_amount,
max_ratio_deviation_percent: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JoinPoolResult {
pub base_deposited: Amount,
pub quote_deposited: Amount,
pub shares_held: Amount,
pub shares_minted: Amount,
}
open_enum! {
LedgerEntryKind {
Deposit => "deposit",
DepositReversal => "deposit_reversal",
WithdrawalDebit => "withdrawal_debit",
WithdrawalFee => "withdrawal_fee",
WithdrawalFeeReserve => "withdrawal_fee_reserve",
WithdrawalRelease => "withdrawal_release",
WithdrawalFeeRelease => "withdrawal_fee_release",
OrderReserve => "order_reserve",
WithdrawalReserve => "withdrawal_reserve",
OrderRelease => "order_release",
TradeDebit => "trade_debit",
TradeCredit => "trade_credit",
TradeFee => "trade_fee",
TransferOut => "transfer_out",
TransferIn => "transfer_in",
TransferInHeld => "transfer_in_held",
TransferRelease => "transfer_release",
TransferReversal => "transfer_reversal",
AdjustmentCredit => "adjustment_credit",
AdjustmentDebit => "adjustment_debit",
Rebate => "rebate",
PoolJoin => "pool_join",
PoolExit => "pool_exit",
FuturesTransferReserve => "futures_transfer_reserve",
FuturesTransferRelease => "futures_transfer_release",
FuturesCollateralSent => "futures_collateral_sent",
FuturesCollateralReturned => "futures_collateral_returned",
WithdrawalRefund => "withdrawal_refund",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerEntry {
pub asset: String,
pub available_after: Amount,
pub available_delta: Amount,
pub created_at: DateTime<Utc>,
pub id: String,
pub kind: LedgerEntryKind,
pub locked_delta: Amount,
pub pending_delta: Amount,
#[serde(default)]
pub reference: LedgerReference,
pub sequence: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceDeposit {
pub deposit_id: DepositId,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceWithdrawal {
pub withdrawal_id: WithdrawalId,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceOrder {
pub order_id: OrderId,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceTrade {
pub order_id: OrderId,
pub trade_id: TradeId,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceTransfer {
pub counterparty_user_id: UserId,
pub transfer_ref: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceAdjustment {
pub operator_user_id: UserId,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferencePool {
pub pool_id: PoolId,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceFuturesTransfer {
pub futures_transfer_id: FuturesTransferId,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LedgerReferenceSystem {
pub cause: String,
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum LedgerReference {
Deposit(LedgerReferenceDeposit),
Withdrawal(LedgerReferenceWithdrawal),
Order(LedgerReferenceOrder),
Trade(LedgerReferenceTrade),
Transfer(LedgerReferenceTransfer),
Adjustment(LedgerReferenceAdjustment),
Pool(LedgerReferencePool),
FuturesTransfer(LedgerReferenceFuturesTransfer),
System(LedgerReferenceSystem),
Unknown(serde_json::Value),
}
impl Default for LedgerReference {
fn default() -> Self {
Self::Unknown(serde_json::Value::Null)
}
}
impl LedgerReference {
pub fn kind(&self) -> &str {
match self {
Self::Deposit(_) => "deposit",
Self::Withdrawal(_) => "withdrawal",
Self::Order(_) => "order",
Self::Trade(_) => "trade",
Self::Transfer(_) => "transfer",
Self::Adjustment(_) => "adjustment",
Self::Pool(_) => "pool",
Self::FuturesTransfer(_) => "futures_transfer",
Self::System(_) => "system",
Self::Unknown(v) => v.get("type").and_then(|t| t.as_str()).unwrap_or(""),
}
}
}
impl<'de> Deserialize<'de> for LedgerReference {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let v = serde_json::Value::deserialize(d)?;
let parsed = match v.get("type").and_then(|t| t.as_str()) {
Some("deposit") => serde_json::from_value(v.clone()).ok().map(Self::Deposit),
Some("withdrawal") => serde_json::from_value(v.clone()).ok().map(Self::Withdrawal),
Some("order") => serde_json::from_value(v.clone()).ok().map(Self::Order),
Some("trade") => serde_json::from_value(v.clone()).ok().map(Self::Trade),
Some("transfer") => serde_json::from_value(v.clone()).ok().map(Self::Transfer),
Some("adjustment") => serde_json::from_value(v.clone()).ok().map(Self::Adjustment),
Some("pool") => serde_json::from_value(v.clone()).ok().map(Self::Pool),
Some("futures_transfer") => serde_json::from_value(v.clone())
.ok()
.map(Self::FuturesTransfer),
Some("system") => serde_json::from_value(v.clone()).ok().map(Self::System),
_ => None,
};
Ok(parsed.unwrap_or(Self::Unknown(v)))
}
}
impl Serialize for LedgerReference {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
let (tag, mut v) = match self {
Self::Deposit(x) => (
"deposit",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::Withdrawal(x) => (
"withdrawal",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::Order(x) => (
"order",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::Trade(x) => (
"trade",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::Transfer(x) => (
"transfer",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::Adjustment(x) => (
"adjustment",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::Pool(x) => (
"pool",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::FuturesTransfer(x) => (
"futures_transfer",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::System(x) => (
"system",
serde_json::to_value(x).map_err(serde::ser::Error::custom)?,
),
Self::Unknown(v) => return v.serialize(s),
};
if let serde_json::Value::Object(m) = &mut v {
m.insert("type".to_owned(), serde_json::Value::String(tag.to_owned()));
}
v.serialize(s)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Level {
pub price: Amount,
pub size: Amount,
}
open_enum! {
LiquidityRole {
Maker => "maker",
Taker => "taker",
}
}
open_enum! {
MaintenanceReason {
ExchangeMaintenance => "exchange_maintenance",
NetworkUnavailable => "network_unavailable",
DepositsDisabled => "deposits_disabled",
WithdrawalsDisabled => "withdrawals_disabled",
AssetUnavailable => "asset_unavailable",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MaintenanceState {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
pub reason: MaintenanceReason,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Market {
pub base_asset: String,
pub best_ask: Amount,
pub best_bid: Amount,
pub change_24h_percent: Amount,
pub high_24h: Amount,
pub last_price: Amount,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_trade_at: Option<DateTime<Utc>>,
pub lot_size: Amount,
pub low_24h: Amount,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_quantity: Option<Amount>,
pub min_notional: Amount,
pub min_quantity: Amount,
pub price_decimals: i32,
pub quantity_decimals: i32,
pub quote_asset: String,
pub quote_volume_24h: Amount,
pub status: MarketStatus,
#[serde(default)]
pub supported_order_types: Vec<OrderType>,
#[serde(default)]
pub supported_time_in_force: Vec<TimeInForce>,
pub symbol: String,
pub tick_size: Amount,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trading_starts_at: Option<DateTime<Utc>>,
pub volume_24h: Amount,
}
open_enum! {
MarketStatus {
Active => "active",
Paused => "paused",
SellOnly => "sell_only",
PreTrading => "pre_trading",
Delisted => "delisted",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Network {
pub average_block_seconds: i32,
pub code: String,
pub deposits_operational: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub explorer_address_url_template: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub explorer_tx_url_template: Option<String>,
pub is_active: bool,
pub name: String,
pub reachable: bool,
}
open_enum! {
NotificationKind {
DepositDetected => "deposit_detected",
DepositCredited => "deposit_credited",
WithdrawalRequested => "withdrawal_requested",
WithdrawalSent => "withdrawal_sent",
WithdrawalCompleted => "withdrawal_completed",
WithdrawalFailed => "withdrawal_failed",
OrderFilled => "order_filled",
OrderClosed => "order_closed",
Security => "security",
ListingDecision => "listing_decision",
Announcement => "announcement",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Notification {
pub body: String,
pub created_at: DateTime<Utc>,
pub id: String,
pub kind: NotificationKind,
pub read: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
pub title: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OpenOrder {
pub coin: String,
pub id: String,
pub order_type: String,
pub original_size: Amount,
pub placed_at: i64,
pub price: Amount,
pub reduce_only: bool,
pub side: String,
pub size: Amount,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trigger_price: Option<Amount>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OrderBook {
#[serde(default)]
pub asks: Vec<Vec<Amount>>,
#[serde(default)]
pub bids: Vec<Vec<Amount>>,
pub sequence: i64,
pub symbol: String,
pub timestamp: DateTime<Utc>,
}
pub type OrderId = String;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Order {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub average_price: Option<Amount>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_order_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub closed_at: Option<DateTime<Utc>>,
pub created_at: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fee_asset: Option<String>,
pub fee_paid: Amount,
pub filled_quantity: Amount,
pub filled_quote_quantity: Amount,
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub price: Option<Amount>,
pub quantity: Amount,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quote_quantity: Option<Amount>,
pub remaining_quantity: Amount,
pub reserved_remaining: Amount,
pub side: OrderSide,
pub status: OrderStatus,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stop_price: Option<Amount>,
pub symbol: String,
pub time_in_force: TimeInForce,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trigger_direction: Option<TriggerDirection>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub triggered_at: Option<DateTime<Utc>>,
pub r#type: OrderType,
pub updated_at: DateTime<Utc>,
}
open_enum! {
OrderSide {
Buy => "buy",
Sell => "sell",
}
}
open_enum! {
OrderStatus {
Pending => "pending",
Open => "open",
PartiallyFilled => "partially_filled",
Filled => "filled",
Cancelled => "cancelled",
Rejected => "rejected",
PendingTrigger => "pending_trigger",
Expired => "expired",
}
}
open_enum! {
OrderType {
Limit => "limit",
Market => "market",
StopLimit => "stop_limit",
StopMarket => "stop_market",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PasswordRules {
pub allows_email_substring: bool,
pub description: String,
pub max_length: i64,
pub min_length: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PerpMarket {
pub coin: String,
pub funding_rate: Amount,
pub mark_price: Amount,
pub max_leverage: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mid_price: Option<Amount>,
pub open_interest: Amount,
pub oracle_price: Amount,
pub price_24h_ago: Amount,
pub size_decimals: i32,
pub volume_24h: Amount,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaceOrderRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_order_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub price: Option<Amount>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quantity: Option<Amount>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quote_quantity: Option<Amount>,
pub side: OrderSide,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stop_price: Option<Amount>,
pub symbol: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub time_in_force: Option<TimeInForce>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trigger_direction: Option<TriggerDirection>,
pub r#type: OrderType,
}
impl PlaceOrderRequest {
pub fn new(symbol: impl Into<String>, side: OrderSide, r#type: OrderType) -> Self {
Self {
symbol: symbol.into(),
side,
r#type,
client_order_id: None,
price: None,
quantity: None,
quote_quantity: None,
stop_price: None,
time_in_force: None,
trigger_direction: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaceOrderResponse {
#[serde(default)]
pub fills: Vec<Fill>,
pub order: Order,
}
pub type PoolId = String;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Pool {
pub base_reserve: Amount,
pub created_at: DateTime<Utc>,
pub fee_percent: String,
pub id: String,
pub ladder_steps: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub price: Option<Amount>,
pub quote_reserve: Amount,
pub shares_outstanding: Amount,
pub status: PoolStatus,
pub symbol: String,
}
open_enum! {
PoolStatus {
Active => "active",
Paused => "paused",
Closing => "closing",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Position {
pub coin: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub entry_price: Option<Amount>,
pub funding_since_open: Amount,
pub leverage: i32,
pub leverage_type: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub liquidation_price: Option<Amount>,
pub margin_used: Amount,
pub position_value: Amount,
pub return_on_equity: Amount,
pub size: Amount,
pub unrealized_pnl: Amount,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Positions {
pub account_value: Amount,
pub maintenance_margin: Amount,
pub margin_used: Amount,
#[serde(default)]
pub positions: Vec<Position>,
pub total_notional: Amount,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FuturesPublicTrade {
pub price: Amount,
pub side: String,
pub size: Amount,
pub time: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PublicTrade {
pub id: String,
pub price: Amount,
pub quantity: Amount,
pub sequence: i64,
pub side: OrderSide,
pub timestamp: DateTime<Utc>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServerTime {
pub epoch_ms: i64,
pub iso: String,
}
open_enum! {
SortDirection {
Asc => "asc",
Desc => "desc",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SubAccount {
pub can_withdraw: bool,
pub created_at: DateTime<Utc>,
pub id: String,
pub is_active: bool,
pub label: String,
}
open_enum! {
TimeInForce {
Gtc => "gtc",
Ioc => "ioc",
Fok => "fok",
PostOnly => "post_only",
}
}
pub type TradeId = String;
open_enum! {
TriggerDirection {
Above => "above",
Below => "below",
}
}
pub type UserId = String;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WithdrawalAddress {
pub address: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub asset: Option<String>,
pub created_at: DateTime<Utc>,
pub id: String,
pub label: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_used_at: Option<DateTime<Utc>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memo: Option<String>,
pub network: String,
pub verified: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WithdrawalHistoryEntry {
pub at: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
pub status: WithdrawalStatus,
}
pub type WithdrawalId = String;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Withdrawal {
pub address: String,
pub amount: Amount,
pub asset: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub broadcast_at: Option<DateTime<Utc>>,
pub cancellable: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub completed_at: Option<DateTime<Utc>>,
pub confirmations: i32,
pub created_at: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub explorer_url: Option<String>,
pub fee: Amount,
pub fee_asset: String,
#[serde(default)]
pub history: Vec<WithdrawalHistoryEntry>,
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub memo: Option<String>,
pub network: String,
pub status: WithdrawalStatus,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub txid: Option<String>,
}
open_enum! {
WithdrawalStatus {
Requested => "requested",
PendingApproval => "pending_approval",
Approved => "approved",
Processing => "processing",
Broadcast => "broadcast",
Completed => "completed",
Rejected => "rejected",
Cancelled => "cancelled",
Failed => "failed",
BroadcastUnknown => "broadcast_unknown",
Reverted => "reverted",
}
}