use std::time::Duration;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::enums::{CancelReason, OrderStatus, OrderType, OrderUpdateType, Side, TimeInForce};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReconnectEvent {
Disconnected,
Attempting {
attempt: u32,
delay: Duration,
},
Reconnected,
Failed { error: String },
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct LeverageSetting {
pub symbol_id: u64,
pub leverage: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct LeverageSettings {
#[serde(default)]
pub settings: Vec<LeverageSetting>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub user_uuid: Option<Uuid>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub server_timestamp: Option<u64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct PlaceOrderOptions {
pub reduce_only: bool,
pub post_only: bool,
pub stp_mode: crate::enums::StpMode,
pub peg_offset_bps: Option<i32>,
pub trigger_price: Option<f64>,
pub take_profit_price: Option<f64>,
pub stop_loss_price: Option<f64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TpslAck {
pub parent_order_id: String,
#[serde(default)]
pub take_profit: Option<String>,
#[serde(default)]
pub stop_loss: Option<String>,
pub error_code: Option<u32>,
pub reject_text: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CountAck {
pub sequence: String,
pub count: u32,
#[serde(default)]
pub order_ids: Vec<String>,
pub error_code: Option<u32>,
pub reject_text: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Confirmation {
Ack,
#[default]
Book,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrderAck {
pub order_id: String,
pub success: bool,
pub sequence: String,
pub error_code: Option<String>,
pub error: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MassQuoteLegInput {
pub side: Side,
pub price: f64,
pub quantity: f64,
#[serde(default)]
pub cancel_order_id: Option<u64>,
#[serde(default)]
pub time_in_force: Option<crate::enums::TimeInForce>,
#[serde(default)]
pub expiry_time: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BatchModifyLegInput {
pub order_id: u64,
#[serde(default)]
pub new_price: Option<f64>,
#[serde(default)]
pub new_quantity: Option<f64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MassQuoteLegResult {
pub leg_index: u32,
pub status: String,
pub cancelled_order_id: Option<String>,
pub new_order_id: Option<String>,
pub error_code: Option<u32>,
pub fill_count: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MassQuoteAck {
pub success: bool,
pub sequence: String,
pub results: Vec<MassQuoteLegResult>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BatchCancelLegResult {
pub order_id: String,
pub cancelled: bool,
pub error_code: Option<u32>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BatchCancelAck {
pub success: bool,
pub sequence: String,
pub results: Vec<BatchCancelLegResult>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BatchModifyLegResult {
pub order_id: String,
pub modified: bool,
pub error_code: Option<u32>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BatchModifyAck {
pub success: bool,
pub sequence: String,
pub results: Vec<BatchModifyLegResult>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OrderUpdate {
pub order_id: String,
pub user_uuid: Uuid,
pub symbol_id: u64,
pub side: Side,
pub status: OrderStatus,
pub update_type: OrderUpdateType,
pub price: String,
pub quantity: String,
pub filled_qty: String,
pub remaining_qty: String,
pub cum_fill: String,
pub cancel_reason: Option<CancelReason>,
pub reject_reason: Option<String>,
pub msg: Option<String>,
pub reduce_only: bool,
pub post_only: bool,
pub correlation_id: u128,
pub timestamp: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MeProfile {
#[serde(default, deserialize_with = "deserialize_null_string")]
pub id: String,
#[serde(default, deserialize_with = "deserialize_null_string")]
pub dynamic_user_id: String,
#[serde(default, deserialize_with = "deserialize_null_string")]
pub email: String,
#[serde(default, deserialize_with = "deserialize_null_string")]
pub wallet_address: String,
#[serde(default, deserialize_with = "deserialize_null_string")]
pub referral_code: String,
#[serde(default, deserialize_with = "deserialize_null_string")]
pub tier: String,
}
fn deserialize_null_string<'de, D>(deserializer: D) -> std::result::Result<String, D::Error>
where
D: serde::Deserializer<'de>,
{
Ok(Option::<String>::deserialize(deserializer)?.unwrap_or_default())
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BalanceUpdate {
pub user_uuid: Uuid,
pub balance_raw: u64,
pub timestamp: u64,
pub balance: String,
pub signed_balance_8dp: i64,
pub free_collateral_8dp: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum PositionsSnapshotSource {
Unspecified,
Initial,
Periodic,
Event,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PositionRow {
pub symbol_id: u64,
pub side: Side,
pub size: String,
pub entry_price: String,
pub leverage: u32,
pub mark_price: Option<String>,
pub unrealized_pnl: Option<String>,
pub notional: Option<String>,
pub mark_publish_time_sec: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PositionsSnapshot {
pub user_uuid: Uuid,
pub rows: Vec<PositionRow>,
pub server_timestamp: u64,
pub source: PositionsSnapshotSource,
pub correlation_id: Option<u128>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SystemHealthUpdate {
pub component_id: String,
pub state: i32,
pub serving: bool,
pub cause: String,
pub updated_at_nanos: u64,
pub sequence: u64,
pub schema_version: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct FundingRateUpdate {
pub symbol_id: u64,
pub funding_rate: String,
pub timestamp: u64,
pub last_funding_rate: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct OpenOrderRow {
pub order_id: String,
pub symbol_id: u64,
pub side: Side,
pub order_type: OrderType,
pub price: String,
pub quantity: String,
pub filled_qty: String,
pub remaining_qty: String,
pub order_status: OrderStatus,
pub time_in_force: TimeInForce,
pub leverage: u32,
pub timestamp: u64,
pub correlation_id: u128,
pub expiry_time: Option<u64>,
pub reduce_only: bool,
pub post_only: bool,
pub take_profit: Option<String>,
pub stop_loss: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct OpenOrdersSnapshot {
pub rows: Vec<OpenOrderRow>,
pub server_timestamp: u64,
pub correlation_id: u128,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AccountMarginSummary {
pub total_collateral: String,
pub position_margin: String,
pub reserved_order_margin: String,
pub free_collateral: String,
pub isolated_margin: String,
pub isolated_equity: String,
pub cross_im: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AccountMarginUpdate {
pub user_uuid: Uuid,
pub server_timestamp: u64,
pub account: Option<AccountMarginSummary>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_order_ack_construction() {
let ack = OrderAck {
order_id: "oid-1".to_string(),
success: true,
sequence: "seq-42".to_string(),
error_code: Some("E1".to_string()),
error: Some("oops".to_string()),
};
assert_eq!(ack.order_id, "oid-1");
assert!(ack.success);
assert_eq!(ack.sequence, "seq-42");
assert_eq!(ack.error_code.as_deref(), Some("E1"));
assert_eq!(ack.error.as_deref(), Some("oops"));
}
#[test]
fn test_order_update_all_fields() {
let u = OrderUpdate {
order_id: "o1".to_string(),
user_uuid: Uuid::nil(),
symbol_id: 200,
side: Side::Sell,
status: OrderStatus::PartiallyFilled,
update_type: OrderUpdateType::PartiallyFilled,
price: "1.5".to_string(),
quantity: "10".to_string(),
filled_qty: "3".to_string(),
remaining_qty: "7".to_string(),
cum_fill: "4.5".to_string(),
cancel_reason: Some(CancelReason::UserRequested),
reject_reason: Some("bad".to_string()),
msg: Some("detail".to_string()),
reduce_only: true,
post_only: false,
correlation_id: 999,
timestamp: 1_700_000_000,
};
assert_eq!(u.order_id, "o1");
assert_eq!(u.user_uuid, Uuid::nil());
assert_eq!(u.symbol_id, 200);
assert_eq!(u.side, Side::Sell);
assert_eq!(u.status, OrderStatus::PartiallyFilled);
assert_eq!(u.update_type, OrderUpdateType::PartiallyFilled);
assert_eq!(u.price, "1.5");
assert_eq!(u.quantity, "10");
assert_eq!(u.filled_qty, "3");
assert_eq!(u.remaining_qty, "7");
assert_eq!(u.cum_fill, "4.5");
assert_eq!(u.cancel_reason, Some(CancelReason::UserRequested));
assert_eq!(u.reject_reason.as_deref(), Some("bad"));
assert_eq!(u.correlation_id, 999);
assert_eq!(u.timestamp, 1_700_000_000);
}
#[test]
fn test_types_clone_and_debug() {
let ack = OrderAck {
order_id: "a".into(),
success: false,
sequence: "s".into(),
error_code: None,
error: None,
};
let _ = ack.clone();
let _ = format!("{:?}", ack);
let ou = OrderUpdate {
order_id: "o".into(),
user_uuid: Uuid::nil(),
symbol_id: 0,
side: Side::Buy,
status: OrderStatus::New,
update_type: OrderUpdateType::Open,
price: "0".into(),
quantity: "0".into(),
filled_qty: "0".into(),
remaining_qty: "0".into(),
cum_fill: "0".into(),
cancel_reason: None,
reject_reason: None,
msg: None,
reduce_only: false,
post_only: false,
correlation_id: 0,
timestamp: 0,
};
let _ = ou.clone();
let _ = format!("{:?}", ou);
}
#[test]
fn test_types_serde_roundtrip() {
let ack = OrderAck {
order_id: "ord".into(),
success: true,
sequence: "1".into(),
error_code: Some("ec".into()),
error: Some("e".into()),
};
let json = serde_json::to_string(&ack).expect("serialize");
let back: OrderAck = serde_json::from_str(&json).expect("deserialize");
assert_eq!(back, ack);
}
}