1use nautilus_core::serialization::{
24 deserialize_decimal_from_str, deserialize_optional_decimal_from_str,
25};
26use nautilus_model::identifiers::{
27 ClientOrderId, InstrumentId, StrategyId, TraderId, VenueOrderId,
28};
29use nautilus_network::websocket::WebSocketClient;
30use rust_decimal::Decimal;
31use serde::{Deserialize, Serialize};
32use ustr::Ustr;
33
34use crate::{
35 common::enums::{
36 BinanceAlgoStatus, BinanceAlgoType, BinanceFuturesOrderType, BinanceFuturesTradeType,
37 BinanceKlineInterval, BinanceMarginType, BinanceOrderStatus, BinancePositionSide,
38 BinancePriceMatch, BinanceSelfTradePreventionMode, BinanceSide, BinanceTimeInForce,
39 BinanceWorkingType, BinanceWsMethod,
40 },
41 futures::http::BinanceFuturesInstrument,
42};
43
44#[derive(Debug, Clone)]
50pub enum BinanceFuturesWsStreamsMessage {
51 AggTrade(BinanceFuturesAggTradeMsg),
53 Trade(BinanceFuturesTradeMsg),
55 BookTicker(BinanceFuturesBookTickerMsg),
57 DepthUpdate(BinanceFuturesDepthUpdateMsg),
59 MarkPrice(BinanceFuturesMarkPriceMsg),
61 Kline(BinanceFuturesKlineMsg),
63 ForceOrder(BinanceFuturesLiquidationMsg),
65 Ticker(BinanceFuturesTickerMsg),
67 AccountUpdate(BinanceFuturesAccountUpdateMsg),
69 OrderUpdate(Box<BinanceFuturesOrderUpdateMsg>),
71 TradeLite(Box<BinanceFuturesTradeLiteMsg>),
73 AlgoUpdate(Box<BinanceFuturesAlgoUpdateMsg>),
75 MarginCall(BinanceFuturesMarginCallMsg),
77 AccountConfigUpdate(BinanceFuturesAccountConfigMsg),
79 ListenKeyExpired,
81 Error(BinanceFuturesWsErrorMsg),
83 Reconnected(Vec<u64>),
86 Unsubscribed {
89 streams: Vec<String>,
91 correlation: Option<u64>,
93 },
94}
95
96#[derive(Debug, Clone)]
98pub struct BinanceFuturesWsErrorMsg {
99 pub code: i64,
101 pub msg: String,
103}
104
105#[derive(Debug)]
107pub enum BinanceFuturesWsStreamsCommand {
108 SetClient(WebSocketClient),
110 Disconnect,
112 Subscribe { streams: Vec<String> },
114 Unsubscribe {
116 streams: Vec<String>,
118 correlation: Option<u64>,
120 },
121}
122
123#[derive(Debug)]
125pub enum ExecHandlerCommand {
126 SetClient(WebSocketClient),
128 Disconnect,
130 InitializeInstruments(Vec<BinanceFuturesInstrument>),
132 UpdateInstrument(BinanceFuturesInstrument),
134 Subscribe { streams: Vec<String> },
136 RegisterOrder {
138 client_order_id: ClientOrderId,
139 trader_id: TraderId,
140 strategy_id: StrategyId,
141 instrument_id: InstrumentId,
142 },
143 RegisterCancel {
145 client_order_id: ClientOrderId,
146 trader_id: TraderId,
147 strategy_id: StrategyId,
148 instrument_id: InstrumentId,
149 venue_order_id: Option<VenueOrderId>,
150 },
151 RegisterModify {
153 client_order_id: ClientOrderId,
154 trader_id: TraderId,
155 strategy_id: StrategyId,
156 instrument_id: InstrumentId,
157 venue_order_id: Option<VenueOrderId>,
158 },
159}
160
161#[derive(Debug, Clone, Deserialize)]
163pub struct BinanceFuturesAggTradeMsg {
164 #[serde(rename = "e")]
166 pub event_type: String,
167 #[serde(rename = "E")]
169 pub event_time: i64,
170 #[serde(rename = "s")]
172 pub symbol: Ustr,
173 #[serde(rename = "a")]
175 pub agg_trade_id: u64,
176 #[serde(rename = "p")]
178 pub price: String,
179 #[serde(rename = "q")]
181 pub quantity: String,
182 #[serde(rename = "f")]
184 pub first_trade_id: u64,
185 #[serde(rename = "l")]
187 pub last_trade_id: u64,
188 #[serde(rename = "T")]
190 pub trade_time: i64,
191 #[serde(rename = "m")]
193 pub is_buyer_maker: bool,
194}
195
196#[derive(Debug, Clone, Deserialize)]
198pub struct BinanceFuturesTradeMsg {
199 #[serde(rename = "e")]
201 pub event_type: String,
202 #[serde(rename = "E")]
204 pub event_time: i64,
205 #[serde(rename = "s")]
207 pub symbol: Ustr,
208 #[serde(rename = "t")]
210 pub trade_id: u64,
211 #[serde(rename = "p")]
213 pub price: String,
214 #[serde(rename = "q")]
216 pub quantity: String,
217 #[serde(rename = "X")]
219 pub trade_type: BinanceFuturesTradeType,
220 #[serde(rename = "T")]
222 pub trade_time: i64,
223 #[serde(rename = "m")]
225 pub is_buyer_maker: bool,
226}
227
228#[derive(Debug, Clone, Deserialize)]
230pub struct BinanceFuturesDepthUpdateMsg {
231 #[serde(rename = "e")]
233 pub event_type: String,
234 #[serde(rename = "E")]
236 pub event_time: i64,
237 #[serde(rename = "T")]
239 pub transaction_time: i64,
240 #[serde(rename = "s")]
242 pub symbol: Ustr,
243 #[serde(rename = "U")]
245 pub first_update_id: u64,
246 #[serde(rename = "u")]
248 pub final_update_id: u64,
249 #[serde(rename = "pu")]
251 pub prev_final_update_id: u64,
252 #[serde(rename = "b")]
254 pub bids: Vec<[String; 2]>,
255 #[serde(rename = "a")]
257 pub asks: Vec<[String; 2]>,
258}
259
260#[derive(Debug, Clone, Deserialize)]
262pub struct BinanceFuturesMarkPriceMsg {
263 #[serde(rename = "e")]
265 pub event_type: String,
266 #[serde(rename = "E")]
268 pub event_time: i64,
269 #[serde(rename = "s")]
271 pub symbol: Ustr,
272 #[serde(rename = "p")]
274 pub mark_price: String,
275 #[serde(rename = "ap", default)]
277 pub mark_price_moving_avg: Option<String>,
278 #[serde(rename = "i")]
280 pub index_price: String,
281 #[serde(rename = "P")]
283 pub estimated_settle_price: String,
284 #[serde(rename = "r")]
286 pub funding_rate: String,
287 #[serde(rename = "T")]
289 pub next_funding_time: i64,
290}
291
292#[derive(Debug, Clone, Deserialize)]
294pub struct BinanceFuturesBookTickerMsg {
295 #[serde(rename = "e")]
297 pub event_type: String,
298 #[serde(rename = "u")]
300 pub update_id: u64,
301 #[serde(rename = "E")]
303 pub event_time: i64,
304 #[serde(rename = "T")]
306 pub transaction_time: i64,
307 #[serde(rename = "s")]
309 pub symbol: Ustr,
310 #[serde(rename = "b")]
312 pub best_bid_price: String,
313 #[serde(rename = "B")]
315 pub best_bid_qty: String,
316 #[serde(rename = "a")]
318 pub best_ask_price: String,
319 #[serde(rename = "A")]
321 pub best_ask_qty: String,
322}
323
324#[derive(Debug, Clone, Deserialize)]
326pub struct BinanceFuturesKlineMsg {
327 #[serde(rename = "e")]
329 pub event_type: String,
330 #[serde(rename = "E")]
332 pub event_time: i64,
333 #[serde(rename = "s")]
335 pub symbol: Ustr,
336 #[serde(rename = "k")]
338 pub kline: BinanceFuturesKlineData,
339}
340
341#[derive(Debug, Clone, Deserialize)]
343pub struct BinanceFuturesKlineData {
344 #[serde(rename = "t")]
346 pub start_time: i64,
347 #[serde(rename = "T")]
349 pub close_time: i64,
350 #[serde(rename = "s")]
352 pub symbol: Ustr,
353 #[serde(rename = "i")]
355 pub interval: BinanceKlineInterval,
356 #[serde(rename = "f")]
358 pub first_trade_id: i64,
359 #[serde(rename = "L")]
361 pub last_trade_id: i64,
362 #[serde(rename = "o")]
364 pub open: String,
365 #[serde(rename = "c")]
367 pub close: String,
368 #[serde(rename = "h")]
370 pub high: String,
371 #[serde(rename = "l")]
373 pub low: String,
374 #[serde(rename = "v")]
376 pub volume: String,
377 #[serde(rename = "n")]
379 pub num_trades: i64,
380 #[serde(rename = "x")]
382 pub is_closed: bool,
383 #[serde(rename = "q")]
385 pub quote_volume: String,
386 #[serde(rename = "V")]
388 pub taker_buy_volume: String,
389 #[serde(rename = "Q")]
391 pub taker_buy_quote_volume: String,
392}
393
394#[derive(Debug, Clone, Deserialize)]
396pub struct BinanceFuturesLiquidationMsg {
397 #[serde(rename = "e")]
399 pub event_type: String,
400 #[serde(rename = "E")]
402 pub event_time: i64,
403 #[serde(rename = "o")]
405 pub order: BinanceFuturesLiquidationOrder,
406}
407
408#[derive(Debug, Clone, Deserialize)]
410pub struct BinanceFuturesLiquidationOrder {
411 #[serde(rename = "s")]
413 pub symbol: Ustr,
414 #[serde(rename = "S")]
416 pub side: BinanceSide,
417 #[serde(rename = "o")]
419 pub order_type: BinanceFuturesOrderType,
420 #[serde(rename = "f")]
422 pub time_in_force: BinanceTimeInForce,
423 #[serde(rename = "q")]
425 pub original_qty: String,
426 #[serde(rename = "p")]
428 pub price: String,
429 #[serde(rename = "ap")]
431 pub average_price: String,
432 #[serde(rename = "X")]
434 pub status: BinanceOrderStatus,
435 #[serde(rename = "l")]
437 pub last_filled_qty: String,
438 #[serde(rename = "z")]
440 pub accumulated_qty: String,
441 #[serde(rename = "T")]
443 pub trade_time: i64,
444}
445
446#[derive(Debug, Clone, Deserialize)]
448pub struct BinanceFuturesTickerMsg {
449 #[serde(rename = "e")]
451 pub event_type: String,
452 #[serde(rename = "E")]
454 pub event_time: i64,
455 #[serde(rename = "s")]
457 pub symbol: Ustr,
458 #[serde(rename = "p")]
460 pub price_change: String,
461 #[serde(rename = "P")]
463 pub price_change_percent: String,
464 #[serde(rename = "w")]
466 pub weighted_avg_price: String,
467 #[serde(rename = "c")]
469 pub last_price: String,
470 #[serde(rename = "Q")]
472 pub last_qty: String,
473 #[serde(rename = "o")]
475 pub open_price: String,
476 #[serde(rename = "h")]
478 pub high_price: String,
479 #[serde(rename = "l")]
481 pub low_price: String,
482 #[serde(rename = "v")]
484 pub volume: String,
485 #[serde(rename = "q")]
487 pub quote_volume: String,
488 #[serde(rename = "O")]
490 pub open_time: i64,
491 #[serde(rename = "C")]
493 pub close_time: i64,
494 #[serde(rename = "F")]
496 pub first_trade_id: i64,
497 #[serde(rename = "L")]
499 pub last_trade_id: i64,
500 #[serde(rename = "n")]
502 pub num_trades: i64,
503}
504
505#[derive(Debug, Clone, Serialize)]
507pub struct BinanceFuturesWsSubscribeRequest {
508 pub method: BinanceWsMethod,
510 pub params: Vec<String>,
512 pub id: u64,
514}
515
516#[derive(Debug, Clone, Deserialize)]
518pub struct BinanceFuturesWsSubscribeResponse {
519 pub result: Option<serde_json::Value>,
521 pub id: u64,
523}
524
525#[derive(Debug, Clone, Deserialize)]
527pub struct BinanceFuturesWsErrorResponse {
528 pub code: i64,
530 pub msg: String,
532 pub id: Option<u64>,
534}
535
536#[derive(Debug, Clone, Deserialize)]
538pub struct BinanceFuturesAccountUpdateMsg {
539 #[serde(rename = "e")]
541 pub event_type: String,
542 #[serde(rename = "E")]
544 pub event_time: i64,
545 #[serde(rename = "T")]
547 pub transaction_time: i64,
548 #[serde(rename = "a")]
550 pub account: AccountUpdateData,
551}
552
553#[derive(Debug, Clone, Deserialize)]
555pub struct AccountUpdateData {
556 #[serde(rename = "m")]
558 pub reason: AccountUpdateReason,
559 #[serde(rename = "B", default)]
561 pub balances: Vec<BalanceUpdate>,
562 #[serde(rename = "P", default)]
564 pub positions: Vec<PositionUpdate>,
565 #[serde(rename = "S", default)]
567 pub symbol: Option<Ustr>,
568}
569
570#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
572#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
573pub enum AccountUpdateReason {
574 Deposit,
575 Withdraw,
576 Order,
577 FundingFee,
578 WithdrawReject,
579 Adjustment,
580 InsuranceClear,
581 AdminDeposit,
582 AdminWithdraw,
583 MarginTransfer,
584 MarginTypeChange,
585 AssetTransfer,
586 OptionsPremiumFee,
587 OptionsSettleProfit,
588 AutoExchange,
589 Adl,
590 CoinSwapDeposit,
591 CoinSwapWithdraw,
592 #[serde(other)]
593 Unknown,
594}
595
596#[derive(Debug, Clone, Deserialize)]
598pub struct BalanceUpdate {
599 #[serde(rename = "a")]
601 pub asset: Ustr,
602 #[serde(rename = "wb", deserialize_with = "deserialize_decimal_from_str")]
604 pub wallet_balance: Decimal,
605 #[serde(rename = "cw", deserialize_with = "deserialize_decimal_from_str")]
607 pub cross_wallet_balance: Decimal,
608 #[serde(
610 rename = "bc",
611 default,
612 deserialize_with = "deserialize_optional_decimal_from_str"
613 )]
614 pub balance_change: Option<Decimal>,
615}
616
617#[derive(Debug, Clone, Deserialize)]
619pub struct PositionUpdate {
620 #[serde(rename = "s")]
622 pub symbol: Ustr,
623 #[serde(rename = "pa")]
625 pub position_amount: String,
626 #[serde(rename = "ep")]
628 pub entry_price: String,
629 #[serde(rename = "bep", default)]
631 pub break_even_price: Option<String>,
632 #[serde(rename = "cr")]
634 pub accumulated_realized: String,
635 #[serde(rename = "up")]
637 pub unrealized_pnl: String,
638 #[serde(rename = "mt")]
640 pub margin_type: BinanceMarginType,
641 #[serde(rename = "iw")]
643 pub isolated_wallet: String,
644 #[serde(rename = "ps")]
646 pub position_side: BinancePositionSide,
647}
648
649#[derive(Debug, Clone, Deserialize)]
651pub struct BinanceFuturesOrderUpdateMsg {
652 #[serde(rename = "e")]
654 pub event_type: String,
655 #[serde(rename = "E")]
657 pub event_time: i64,
658 #[serde(rename = "T")]
660 pub transaction_time: i64,
661 #[serde(rename = "o")]
663 pub order: OrderUpdateData,
664}
665
666#[derive(Debug, Clone, Deserialize)]
668pub struct OrderUpdateData {
669 #[serde(rename = "s")]
671 pub symbol: Ustr,
672 #[serde(rename = "c")]
674 pub client_order_id: String,
675 #[serde(rename = "S")]
677 pub side: BinanceSide,
678 #[serde(rename = "o")]
680 pub order_type: BinanceFuturesOrderType,
681 #[serde(rename = "f")]
683 pub time_in_force: BinanceTimeInForce,
684 #[serde(rename = "q")]
686 pub original_qty: String,
687 #[serde(rename = "p")]
689 pub original_price: String,
690 #[serde(rename = "ap")]
692 pub average_price: String,
693 #[serde(rename = "sp")]
695 pub stop_price: String,
696 #[serde(rename = "x")]
698 pub execution_type: BinanceExecutionType,
699 #[serde(rename = "X")]
701 pub order_status: BinanceOrderStatus,
702 #[serde(rename = "i")]
704 pub order_id: i64,
705 #[serde(rename = "l")]
707 pub last_filled_qty: String,
708 #[serde(rename = "z")]
710 pub cumulative_filled_qty: String,
711 #[serde(rename = "L")]
713 pub last_filled_price: String,
714 #[serde(rename = "N", default)]
716 pub commission_asset: Option<Ustr>,
717 #[serde(rename = "n", default)]
719 pub commission: Option<String>,
720 #[serde(rename = "T")]
722 pub trade_time: i64,
723 #[serde(rename = "t")]
725 pub trade_id: i64,
726 #[serde(rename = "b", default)]
728 pub bids_notional: Option<String>,
729 #[serde(rename = "a", default)]
731 pub asks_notional: Option<String>,
732 #[serde(rename = "m")]
734 pub is_maker: bool,
735 #[serde(rename = "R")]
737 pub is_reduce_only: bool,
738 #[serde(rename = "wt")]
740 pub working_type: BinanceWorkingType,
741 #[serde(rename = "ot")]
743 pub original_order_type: BinanceFuturesOrderType,
744 #[serde(rename = "ps")]
746 pub position_side: BinancePositionSide,
747 #[serde(rename = "cp", default)]
749 pub close_position: Option<bool>,
750 #[serde(rename = "AP", default)]
752 pub activation_price: Option<String>,
753 #[serde(rename = "cr", default)]
755 pub callback_rate: Option<String>,
756 #[serde(rename = "pP", default)]
758 pub price_protect: Option<bool>,
759 #[serde(rename = "rp")]
761 pub realized_profit: String,
762 #[serde(rename = "V", default)]
764 pub stp_mode: Option<BinanceSelfTradePreventionMode>,
765 #[serde(rename = "pm", default)]
767 pub price_match: Option<BinancePriceMatch>,
768 #[serde(rename = "gtd", default)]
770 pub good_till_date: Option<i64>,
771}
772
773impl OrderUpdateData {
774 #[must_use]
776 pub fn is_liquidation(&self) -> bool {
777 self.client_order_id.starts_with("autoclose-")
778 }
779
780 #[must_use]
782 pub fn is_adl(&self) -> bool {
783 self.client_order_id.starts_with("adl_autoclose")
784 }
785
786 #[must_use]
792 pub fn is_settlement(&self) -> bool {
793 self.client_order_id.starts_with("settlement_autoclose-")
794 || self.client_order_id.starts_with("delivery_autoclose-")
795 }
796
797 #[must_use]
799 pub fn is_exchange_generated(&self) -> bool {
800 self.is_liquidation() || self.is_adl() || self.is_settlement()
801 }
802}
803
804#[derive(Debug, Clone, Deserialize)]
811pub struct BinanceFuturesTradeLiteMsg {
812 #[serde(rename = "e")]
814 pub event_type: String,
815 #[serde(rename = "E")]
817 pub event_time: i64,
818 #[serde(rename = "T")]
820 pub transaction_time: i64,
821 #[serde(rename = "s")]
823 pub symbol: Ustr,
824 #[serde(rename = "c")]
826 pub client_order_id: String,
827 #[serde(rename = "S")]
829 pub side: BinanceSide,
830 #[serde(rename = "q")]
832 pub original_qty: String,
833 #[serde(rename = "p")]
835 pub original_price: String,
836 #[serde(rename = "i")]
838 pub order_id: i64,
839 #[serde(rename = "l")]
841 pub last_filled_qty: String,
842 #[serde(rename = "L")]
844 pub last_filled_price: String,
845 #[serde(rename = "t")]
847 pub trade_id: i64,
848 #[serde(rename = "m")]
850 pub is_maker: bool,
851}
852
853#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq)]
855#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
856pub enum BinanceExecutionType {
857 New,
859 Canceled,
861 Calculated,
863 Expired,
865 Trade,
867 Amendment,
869 #[serde(other)]
871 Unknown,
872}
873
874#[derive(Debug, Clone, Deserialize)]
876pub struct BinanceFuturesMarginCallMsg {
877 #[serde(rename = "e")]
879 pub event_type: String,
880 #[serde(rename = "E")]
882 pub event_time: i64,
883 #[serde(rename = "cw")]
885 pub cross_wallet_balance: String,
886 #[serde(rename = "p")]
888 pub positions: Vec<MarginCallPosition>,
889}
890
891#[derive(Debug, Clone, Deserialize)]
893pub struct MarginCallPosition {
894 #[serde(rename = "s")]
896 pub symbol: Ustr,
897 #[serde(rename = "ps")]
899 pub position_side: BinancePositionSide,
900 #[serde(rename = "pa")]
902 pub position_amount: String,
903 #[serde(rename = "mt")]
905 pub margin_type: BinanceMarginType,
906 #[serde(rename = "iw")]
908 pub isolated_wallet: String,
909 #[serde(rename = "mp")]
911 pub mark_price: String,
912 #[serde(rename = "up")]
914 pub unrealized_pnl: String,
915 #[serde(rename = "mm")]
917 pub maintenance_margin: String,
918}
919
920#[derive(Debug, Clone, Deserialize)]
922pub struct BinanceFuturesAccountConfigMsg {
923 #[serde(rename = "e")]
925 pub event_type: String,
926 #[serde(rename = "E")]
928 pub event_time: i64,
929 #[serde(rename = "T")]
931 pub transaction_time: i64,
932 #[serde(rename = "ac", default)]
934 pub leverage_config: Option<LeverageConfig>,
935 #[serde(rename = "ai", default)]
937 pub asset_index: Option<AssetIndexConfig>,
938}
939
940#[derive(Debug, Clone, Deserialize)]
942pub struct LeverageConfig {
943 #[serde(rename = "s")]
945 pub symbol: Ustr,
946 #[serde(rename = "l")]
948 pub leverage: u32,
949}
950
951#[derive(Debug, Clone, Deserialize)]
953pub struct AssetIndexConfig {
954 #[serde(rename = "s")]
956 pub symbol: Ustr,
957}
958
959#[derive(Debug, Clone, Deserialize)]
969pub struct BinanceFuturesAlgoUpdateMsg {
970 #[serde(rename = "e")]
972 pub event_type: String,
973 #[serde(rename = "E")]
975 pub event_time: i64,
976 #[serde(rename = "T")]
978 pub transaction_time: i64,
979 #[serde(rename = "o", alias = "ao")]
981 pub algo_order: AlgoOrderUpdateData,
982}
983
984#[derive(Debug, Clone, Deserialize)]
986pub struct AlgoOrderUpdateData {
987 #[serde(rename = "caid")]
989 pub client_algo_id: String,
990 #[serde(rename = "aid")]
992 pub algo_id: i64,
993 #[serde(rename = "at")]
995 pub algo_type: BinanceAlgoType,
996 #[serde(rename = "o")]
998 pub order_type: BinanceFuturesOrderType,
999 #[serde(rename = "s")]
1001 pub symbol: Ustr,
1002 #[serde(rename = "S")]
1004 pub side: BinanceSide,
1005 #[serde(rename = "ps")]
1007 pub position_side: BinancePositionSide,
1008 #[serde(rename = "f")]
1010 pub time_in_force: BinanceTimeInForce,
1011 #[serde(rename = "q")]
1013 pub quantity: String,
1014 #[serde(rename = "X")]
1016 pub algo_status: BinanceAlgoStatus,
1017 #[serde(rename = "tp")]
1019 pub trigger_price: String,
1020 #[serde(rename = "p")]
1022 pub price: String,
1023 #[serde(rename = "wt")]
1025 pub working_type: BinanceWorkingType,
1026 #[serde(rename = "pm", default)]
1028 pub price_match: Option<BinancePriceMatch>,
1029 #[serde(rename = "cp", default)]
1031 pub close_position: Option<bool>,
1032 #[serde(rename = "pP", default)]
1034 pub price_protect: Option<bool>,
1035 #[serde(rename = "R", default)]
1037 pub reduce_only: Option<bool>,
1038 #[serde(rename = "tt", default)]
1040 pub trigger_time: Option<i64>,
1041 #[serde(rename = "gtd", default)]
1043 pub good_till_date: Option<i64>,
1044 #[serde(rename = "ai", default)]
1046 pub actual_order_id: Option<String>,
1047 #[serde(rename = "ap", default)]
1049 pub avg_price: Option<String>,
1050 #[serde(rename = "aq", default)]
1052 pub executed_qty: Option<String>,
1053 #[serde(rename = "act", default)]
1055 pub actual_order_type: Option<String>,
1056 #[serde(rename = "cr", default)]
1058 pub callback_rate: Option<String>,
1059 #[serde(rename = "V", default)]
1061 pub stp_mode: Option<BinanceSelfTradePreventionMode>,
1062}
1063
1064#[derive(Debug, Clone, Deserialize)]
1066pub struct BinanceFuturesListenKeyExpiredMsg {
1067 #[serde(rename = "e")]
1069 pub event_type: String,
1070 #[serde(rename = "E")]
1072 pub event_time: i64,
1073}
1074
1075#[cfg(test)]
1076mod tests {
1077 use rstest::rstest;
1078 use rust_decimal_macros::dec;
1079
1080 use super::*;
1081
1082 #[rstest]
1083 #[case(
1084 include_str!("../../../../test_data/futures/user_data_json/account_update_funding_fee_usdm.json"),
1085 "BTCUSDT",
1086 "USDT",
1087 [1786060800001, 1786060800000],
1088 [dec!(1024.12345678), dec!(1010.87654321), dec!(-0.01234567)]
1089 )]
1090 #[case(
1091 include_str!("../../../../test_data/futures/user_data_json/account_update_funding_fee_coinm.json"),
1092 "BTCUSD_PERP",
1093 "BTC",
1094 [1786089600002, 1786089600000],
1095 [dec!(1.23456789), dec!(1.12345678), dec!(0.00001234)]
1096 )]
1097 fn test_account_update_funding_fee_symbol(
1098 #[case] payload: &str,
1099 #[case] symbol: &str,
1100 #[case] asset: &str,
1101 #[case] times: [i64; 2],
1102 #[case] balances: [Decimal; 3],
1103 ) {
1104 let msg: BinanceFuturesAccountUpdateMsg = serde_json::from_str(payload).unwrap();
1105
1106 assert_eq!(msg.event_type, "ACCOUNT_UPDATE");
1107 assert_eq!(msg.event_time, times[0]);
1108 assert_eq!(msg.transaction_time, times[1]);
1109 assert_eq!(msg.account.reason, AccountUpdateReason::FundingFee);
1110 assert_eq!(msg.account.symbol, Some(Ustr::from(symbol)));
1111 assert_eq!(msg.account.balances.len(), 1);
1112 assert_eq!(msg.account.positions.len(), 0);
1113 let balance = &msg.account.balances[0];
1114 assert_eq!(balance.asset, Ustr::from(asset));
1115 assert_eq!(balance.wallet_balance, balances[0]);
1116 assert_eq!(balance.cross_wallet_balance, balances[1]);
1117 assert_eq!(balance.balance_change, Some(balances[2]));
1118 }
1119
1120 #[rstest]
1121 #[case(include_str!("../../../../test_data/futures/user_data_json/account_update.json"), 1, 3)]
1122 #[case(include_str!("../../../../test_data/futures/user_data_json/account_update_bnfcr.json"), 1, 0)]
1123 fn test_account_update_without_symbol(
1124 #[case] payload: &str,
1125 #[case] balances: usize,
1126 #[case] positions: usize,
1127 ) {
1128 let msg: BinanceFuturesAccountUpdateMsg = serde_json::from_str(payload).unwrap();
1129
1130 assert_eq!(msg.account.reason, AccountUpdateReason::Order);
1131 assert_eq!(msg.account.symbol, None);
1132 assert_eq!(msg.account.balances.len(), balances);
1133 assert_eq!(msg.account.positions.len(), positions);
1134 }
1135
1136 #[rstest]
1137 #[case(include_str!("../../../../test_data/futures/user_data_json/account_update_funding_fee_usdm.json"))]
1138 #[case(include_str!("../../../../test_data/futures/user_data_json/account_update_funding_fee_coinm.json"))]
1139 fn test_account_update_funding_fee_without_symbol(#[case] payload: &str) {
1140 let mut payload: serde_json::Value = serde_json::from_str(payload).unwrap();
1141 payload["a"].as_object_mut().unwrap().remove("S");
1142
1143 let msg: BinanceFuturesAccountUpdateMsg = serde_json::from_value(payload).unwrap();
1144
1145 assert_eq!(msg.account.reason, AccountUpdateReason::FundingFee);
1146 assert_eq!(msg.account.symbol, None);
1147 }
1148
1149 #[rstest]
1150 fn test_account_update_reason_adl_deserializes() {
1151 let value: AccountUpdateReason = serde_json::from_str("\"ADL\"").unwrap();
1152 assert_eq!(value, AccountUpdateReason::Adl);
1153 }
1154
1155 #[rstest]
1156 fn test_account_update_reason_unknown_fallback() {
1157 let value: AccountUpdateReason = serde_json::from_str("\"SOMETHING_NEW\"").unwrap();
1158 assert_eq!(value, AccountUpdateReason::Unknown);
1159 }
1160}