1use anyhow::Context;
19use nautilus_core::{UUID4, datetime::NANOSECONDS_IN_MILLISECOND, nanos::UnixNanos};
20use nautilus_model::{
21 data::{
22 BookOrder, FundingRateUpdate, IndexPriceUpdate, MarkPriceUpdate, OrderBookDelta, QuoteTick,
23 TradeTick,
24 },
25 enums::{
26 AggressorSide, BookAction, OrderSide, OrderStatus, OrderType, RecordFlag, TriggerType,
27 },
28 identifiers::{AccountId, ClientOrderId, TradeId},
29 instruments::{Instrument, any::InstrumentAny},
30 reports::{FillReport, OrderStatusReport},
31 types::{Money, Price, Quantity},
32};
33use rust_decimal::Decimal;
34
35use super::messages::{
36 KrakenFuturesBookDelta, KrakenFuturesBookSnapshot, KrakenFuturesFill, KrakenFuturesOpenOrder,
37 KrakenFuturesTickerData, KrakenFuturesTradeData,
38};
39use crate::common::{
40 enums::KrakenOrderSide,
41 parse::{fee_currency, parse_futures_order_type_time_in_force, parse_venue_order_id},
42};
43
44fn millis_to_nanos(millis: i64) -> UnixNanos {
45 UnixNanos::from((millis as u64) * NANOSECONDS_IN_MILLISECOND)
46}
47
48pub fn parse_futures_ws_quote_tick(
49 ticker: &KrakenFuturesTickerData,
50 instrument: &InstrumentAny,
51 ts_init: UnixNanos,
52) -> anyhow::Result<QuoteTick> {
53 let price_precision = instrument.price_precision();
54 let size_precision = instrument.size_precision();
55
56 let bid = ticker.bid.context("Ticker missing bid")?;
57 let ask = ticker.ask.context("Ticker missing ask")?;
58 let bid_size = ticker.bid_size.unwrap_or(Decimal::ZERO);
59 let ask_size = ticker.ask_size.unwrap_or(Decimal::ZERO);
60
61 let bid_price =
62 Price::from_decimal_dp(bid, price_precision).context("Failed to construct bid Price")?;
63 let ask_price =
64 Price::from_decimal_dp(ask, price_precision).context("Failed to construct ask Price")?;
65 let bid_qty = Quantity::from_decimal_dp(bid_size, size_precision)
66 .context("Failed to construct bid Quantity")?;
67 let ask_qty = Quantity::from_decimal_dp(ask_size, size_precision)
68 .context("Failed to construct ask Quantity")?;
69
70 let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
71
72 Ok(QuoteTick::new(
73 instrument.id(),
74 bid_price,
75 ask_price,
76 bid_qty,
77 ask_qty,
78 ts_event,
79 ts_init,
80 ))
81}
82
83pub fn parse_futures_ws_trade_tick(
84 trade: &KrakenFuturesTradeData,
85 instrument: &InstrumentAny,
86 ts_init: UnixNanos,
87) -> anyhow::Result<TradeTick> {
88 let price_precision = instrument.price_precision();
89 let size_precision = instrument.size_precision();
90
91 let price = Price::from_decimal_dp(trade.price, price_precision)
92 .context("Failed to construct trade Price")?;
93 let size = Quantity::from_decimal_dp(trade.qty, size_precision)
94 .context("Failed to construct trade Quantity")?;
95
96 let aggressor = match trade.side {
97 KrakenOrderSide::Buy => AggressorSide::Buy,
98 KrakenOrderSide::Sell => AggressorSide::Sell,
99 };
100
101 let trade_id = trade
102 .uid
103 .as_deref()
104 .map_or_else(|| TradeId::new(trade.seq.to_string()), TradeId::new);
105
106 let ts_event = millis_to_nanos(trade.time);
107
108 TradeTick::new_checked(
109 instrument.id(),
110 price,
111 size,
112 aggressor,
113 trade_id,
114 ts_event,
115 ts_init,
116 )
117 .context("Failed to construct TradeTick from Kraken futures trade")
118}
119
120pub fn parse_futures_ws_book_snapshot_deltas(
121 snapshot: &KrakenFuturesBookSnapshot,
122 instrument: &InstrumentAny,
123 sequence: u64,
124 ts_init: UnixNanos,
125) -> anyhow::Result<Vec<OrderBookDelta>> {
126 let instrument_id = instrument.id();
127 let price_precision = instrument.price_precision();
128 let size_precision = instrument.size_precision();
129 let ts_event = millis_to_nanos(snapshot.timestamp);
130
131 let capacity = snapshot.bids.len() + snapshot.asks.len() + 1;
132 let mut deltas = Vec::with_capacity(capacity);
133 let mut seq = sequence;
134
135 deltas.push(OrderBookDelta::clear(instrument_id, seq, ts_event, ts_init));
137 seq += 1;
138
139 for level in &snapshot.bids {
140 if level.qty <= Decimal::ZERO {
141 continue;
142 }
143 let price = Price::from_decimal_dp(level.price, price_precision)?;
144 let size = Quantity::from_decimal_dp(level.qty, size_precision)?;
145 let order_id = price.raw() as u64;
146
147 let order = BookOrder::new(OrderSide::Buy, price, size, order_id);
148 deltas.push(OrderBookDelta::new(
149 instrument_id,
150 BookAction::Add,
151 order,
152 RecordFlag::F_SNAPSHOT as u8,
153 seq,
154 ts_event,
155 ts_init,
156 ));
157 seq += 1;
158 }
159
160 for level in &snapshot.asks {
161 if level.qty <= Decimal::ZERO {
162 continue;
163 }
164 let price = Price::from_decimal_dp(level.price, price_precision)?;
165 let size = Quantity::from_decimal_dp(level.qty, size_precision)?;
166 let order_id = price.raw() as u64;
167
168 let order = BookOrder::new(OrderSide::Sell, price, size, order_id);
169 deltas.push(OrderBookDelta::new(
170 instrument_id,
171 BookAction::Add,
172 order,
173 RecordFlag::F_SNAPSHOT as u8,
174 seq,
175 ts_event,
176 ts_init,
177 ));
178 seq += 1;
179 }
180
181 if let Some(last) = deltas.last_mut() {
182 last.flags |= RecordFlag::F_LAST as u8;
183 }
184
185 Ok(deltas)
186}
187
188pub fn parse_futures_ws_book_delta(
189 delta: &KrakenFuturesBookDelta,
190 instrument: &InstrumentAny,
191 sequence: u64,
192 ts_init: UnixNanos,
193) -> anyhow::Result<OrderBookDelta> {
194 let price_precision = instrument.price_precision();
195 let size_precision = instrument.size_precision();
196
197 let price = Price::from_decimal_dp(delta.price, price_precision)?;
198 let size = Quantity::from_decimal_dp(delta.qty, size_precision)?;
199
200 let action = if size.is_zero() {
201 BookAction::Delete
202 } else {
203 BookAction::Update
204 };
205
206 let side = match delta.side {
207 KrakenOrderSide::Buy => OrderSide::Buy,
208 KrakenOrderSide::Sell => OrderSide::Sell,
209 };
210
211 let order_id = price.raw() as u64;
212
213 let order = BookOrder::new(side, price, size, order_id);
214 let ts_event = millis_to_nanos(delta.timestamp);
215
216 Ok(OrderBookDelta::new(
217 instrument.id(),
218 action,
219 order,
220 RecordFlag::F_LAST as u8,
221 sequence,
222 ts_event,
223 ts_init,
224 ))
225}
226
227fn parse_ws_direction(direction: i32) -> OrderSide {
228 if direction == 0 {
229 OrderSide::Buy
230 } else {
231 OrderSide::Sell
232 }
233}
234
235fn infer_order_status(order: &KrakenFuturesOpenOrder, is_cancel: bool) -> OrderStatus {
236 if order.filled >= order.qty && order.qty > Decimal::ZERO {
237 OrderStatus::Filled
238 } else if is_cancel {
239 OrderStatus::Canceled
240 } else if order.filled > Decimal::ZERO {
241 OrderStatus::PartiallyFilled
242 } else {
243 OrderStatus::Accepted
244 }
245}
246
247pub fn parse_futures_ws_order_status_report(
248 order: &KrakenFuturesOpenOrder,
249 is_cancel: bool,
250 reason: Option<&str>,
251 instrument: &InstrumentAny,
252 account_id: AccountId,
253 ts_init: UnixNanos,
254) -> anyhow::Result<OrderStatusReport> {
255 let venue_order_id = parse_venue_order_id(&order.order_id, "futures order delta")?;
256 let order_side = parse_ws_direction(order.direction);
257 let order_type = OrderType::from(order.order_type);
258 let order_type = if order_type == OrderType::MarketIfTouched && order.limit_price.is_some() {
259 OrderType::LimitIfTouched
260 } else {
261 order_type
262 };
263 let order_status = infer_order_status(order, is_cancel);
264 let (time_in_force, post_only) = parse_futures_order_type_time_in_force(order.order_type);
265
266 let price_precision = instrument.price_precision();
267 let size_precision = instrument.size_precision();
268
269 let quantity = Quantity::from_decimal_dp(order.qty, size_precision)
270 .context("Failed to parse order qty")?;
271 let filled_qty = Quantity::from_decimal_dp(order.filled, size_precision)
272 .context("Failed to parse order filled")?;
273
274 let ts_accepted = millis_to_nanos(order.time);
275 let ts_last = millis_to_nanos(order.last_update_time);
276
277 let mut report = OrderStatusReport {
278 account_id,
279 instrument_id: instrument.id(),
280 client_order_id: order.cli_ord_id.as_ref().map(ClientOrderId::new),
281 venue_order_id,
282 order_side: order_side.into(),
283 order_type,
284 time_in_force,
285 order_status,
286 quantity,
287 filled_qty,
288 report_id: UUID4::new(),
289 ts_accepted,
290 ts_last,
291 ts_init,
292 order_list_id: None,
293 venue_position_id: None,
294 linked_order_ids: None,
295 parent_order_id: None,
296 contingency_type: None,
297 expire_time: None,
298 price: None,
299 activation_price: None,
300 trigger_price: None,
301 trigger_type: None,
302 limit_offset: None,
303 trailing_offset: None,
304 trailing_offset_type: None,
305 display_qty: None,
306 avg_px: None,
307 post_only,
308 reduce_only: order.reduce_only,
309 cancel_reason: None,
310 ts_triggered: None,
311 };
312
313 if let Some(px) = order.limit_price {
314 report.price = Some(Price::from_decimal_dp(px, price_precision)?);
315 }
316
317 if let Some(px) = order.stop_price {
318 report.trigger_price = Some(Price::from_decimal_dp(px, price_precision)?);
319 report.trigger_type = Some(order.trigger_signal.as_deref().map_or(
320 TriggerType::Default,
321 |s| match s {
322 "mark" | "mark_price" => TriggerType::MarkPrice,
323 "spot" | "spot_price" | "index" | "index_price" => TriggerType::IndexPrice,
324 _ => TriggerType::LastPrice,
325 },
326 ));
327 }
328
329 if let Some(reason) = reason
330 && !reason.is_empty()
331 {
332 report.cancel_reason = Some(reason.to_string());
333 }
334
335 Ok(report)
336}
337
338pub fn parse_futures_ws_fill_report(
339 fill: &KrakenFuturesFill,
340 instrument: &InstrumentAny,
341 account_id: AccountId,
342 ts_init: UnixNanos,
343) -> anyhow::Result<FillReport> {
344 let price_precision = instrument.price_precision();
345 let size_precision = instrument.size_precision();
346
347 let venue_order_id = parse_venue_order_id(
348 &fill.order_id,
349 format_args!("futures fill {}", fill.fill_id),
350 )?;
351 let trade_id = TradeId::new(&fill.fill_id);
352 let order_side = if fill.buy {
353 OrderSide::Buy
354 } else {
355 OrderSide::Sell
356 };
357
358 let last_qty =
359 Quantity::from_decimal_dp(fill.qty, size_precision).context("Failed to parse fill qty")?;
360 let last_px = Price::from_decimal_dp(fill.price, price_precision)
361 .context("Failed to parse fill price")?;
362
363 let liquidity_side = fill.fill_type.into();
364
365 let fee = fill.fee_paid.unwrap_or(Decimal::ZERO);
366 let commission_currency = fill.fee_currency.as_deref().map_or_else(
368 || instrument.quote_currency(),
369 |reported| fee_currency(reported, instrument),
370 );
371 let commission = Money::from_decimal(fee, commission_currency)?;
372
373 let ts_event = millis_to_nanos(fill.time);
374
375 let client_order_id = fill
376 .cli_ord_id
377 .as_ref()
378 .filter(|s| !s.is_empty())
379 .map(ClientOrderId::new);
380
381 Ok(FillReport::new(
382 account_id,
383 instrument.id(),
384 venue_order_id,
385 trade_id,
386 order_side,
387 last_qty,
388 last_px,
389 commission,
390 liquidity_side,
391 client_order_id,
392 None, ts_event,
394 ts_init,
395 None, ))
397}
398
399pub fn parse_futures_ws_mark_price(
400 ticker: &KrakenFuturesTickerData,
401 instrument: &InstrumentAny,
402 ts_init: UnixNanos,
403) -> Option<MarkPriceUpdate> {
404 let mark_price = ticker.mark_price?;
405 let price = Price::from_decimal_dp(mark_price, instrument.price_precision()).ok()?;
406 let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
407 Some(MarkPriceUpdate::new(
408 instrument.id(),
409 price,
410 ts_event,
411 ts_init,
412 ))
413}
414
415pub fn parse_futures_ws_index_price(
416 ticker: &KrakenFuturesTickerData,
417 instrument: &InstrumentAny,
418 ts_init: UnixNanos,
419) -> Option<IndexPriceUpdate> {
420 let index = ticker.index?;
421 let price = Price::from_decimal_dp(index, instrument.price_precision()).ok()?;
422 let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
423 Some(IndexPriceUpdate::new(
424 instrument.id(),
425 price,
426 ts_event,
427 ts_init,
428 ))
429}
430
431pub fn parse_futures_ws_funding_rate(
432 ticker: &KrakenFuturesTickerData,
433 instrument: &InstrumentAny,
434 ts_init: UnixNanos,
435) -> Option<FundingRateUpdate> {
436 let rate = ticker.relative_funding_rate?;
437 let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
438 let next_funding_ns = ticker
439 .next_funding_rate_time
440 .map(|t| millis_to_nanos(t as i64));
441 Some(FundingRateUpdate::new(
442 instrument.id(),
443 rate,
444 None,
445 next_funding_ns,
446 ts_event,
447 ts_init,
448 ))
449}
450
451#[cfg(test)]
452mod tests {
453 use nautilus_model::{
454 data::OrderBookDeltas,
455 enums::{CurrencyType, LiquiditySide, OrderSide, TimeInForce},
456 identifiers::{InstrumentId, Symbol},
457 instruments::crypto_perpetual::CryptoPerpetual,
458 types::Currency,
459 };
460 use rstest::rstest;
461 use rust_decimal_macros::dec;
462
463 use super::*;
464 use crate::common::{
465 consts::KRAKEN_VENUE,
466 enums::{KrakenFillType, KrakenFuturesOrderType},
467 };
468
469 const TS: UnixNanos = UnixNanos::new(1_700_000_000_000_000_000);
470
471 fn create_mock_perp() -> InstrumentAny {
472 let instrument_id = InstrumentId::new(Symbol::new("PI_XBTUSD"), *KRAKEN_VENUE);
473 InstrumentAny::CryptoPerpetual(
474 CryptoPerpetual::builder()
475 .instrument_id(instrument_id)
476 .raw_symbol(Symbol::new("PI_XBTUSD"))
477 .base_currency(Currency::BTC())
478 .quote_currency(Currency::USD())
479 .settlement_currency(Currency::USD())
480 .is_inverse(false)
481 .price_precision(1)
482 .size_precision(0)
483 .price_increment(Price::from("0.5"))
484 .size_increment(Quantity::from("1"))
485 .ts_event(TS)
486 .ts_init(TS)
487 .build()
488 .unwrap(),
489 )
490 }
491
492 #[rstest]
493 fn test_parse_futures_ws_quote_tick() {
494 let json = include_str!("../../../test_data/ws_futures_ticker.json");
495 let ticker: KrakenFuturesTickerData = serde_json::from_str(json).unwrap();
496 let instrument = create_mock_perp();
497
498 let quote = parse_futures_ws_quote_tick(&ticker, &instrument, TS).unwrap();
499
500 assert_eq!(quote.instrument_id, instrument.id());
501 assert_eq!(quote.bid_price, Price::from("21978.5"));
502 assert_eq!(quote.ask_price, Price::from("21987.0"));
503 assert_eq!(quote.bid_size, Quantity::from("2536.0"));
504 assert_eq!(quote.ask_size, Quantity::from("13948.0"));
505 }
506
507 #[rstest]
508 fn test_parse_futures_ws_trade_tick() {
509 let json = include_str!("../../../test_data/ws_futures_trade.json");
510 let trade: KrakenFuturesTradeData = serde_json::from_str(json).unwrap();
511 let instrument = create_mock_perp();
512
513 let tick = parse_futures_ws_trade_tick(&trade, &instrument, TS).unwrap();
514
515 assert_eq!(tick.instrument_id, instrument.id());
516 assert_eq!(tick.price, Price::from("34969.5"));
517 assert_eq!(tick.size, Quantity::from("15000.0"));
518 assert_eq!(tick.aggressor_side, AggressorSide::Sell);
519 }
520
521 fn assert_snapshot_delta_flags(instrument_id: InstrumentId, deltas: Vec<OrderBookDelta>) {
522 assert!(!deltas.is_empty());
523 assert!(
524 deltas
525 .iter()
526 .all(|d| RecordFlag::F_SNAPSHOT.matches(d.flags))
527 );
528 let (last, init) = deltas.split_last().unwrap();
529 assert!(init.iter().all(|d| !RecordFlag::F_LAST.matches(d.flags)));
530 assert!(RecordFlag::F_LAST.matches(last.flags));
531
532 let batch = OrderBookDeltas::new(instrument_id, deltas);
533 assert!(RecordFlag::F_SNAPSHOT.matches(batch.flags));
534 assert!(RecordFlag::F_LAST.matches(batch.flags));
535 }
536
537 #[rstest]
538 fn test_parse_futures_ws_book_snapshot() {
539 let json = include_str!("../../../test_data/ws_futures_book_snapshot.json");
540 let snapshot: KrakenFuturesBookSnapshot = serde_json::from_str(json).unwrap();
541 let instrument = create_mock_perp();
542
543 let deltas = parse_futures_ws_book_snapshot_deltas(&snapshot, &instrument, 0, TS).unwrap();
544
545 assert_eq!(deltas.len(), 5);
547 assert_eq!(deltas[0].action, BookAction::Clear);
548 assert_eq!(deltas[1].action, BookAction::Add);
549 assert_eq!(deltas[1].order.side, OrderSide::Buy.into());
550 assert_eq!(deltas[3].order.side, OrderSide::Sell.into());
551 assert_snapshot_delta_flags(instrument.id(), deltas);
552 }
553
554 #[rstest]
555 fn test_parse_futures_ws_book_snapshot_skips_zero_qty() {
556 let json = include_str!("../../../test_data/ws_futures_book_snapshot_with_zero_qty.json");
557 let snapshot: KrakenFuturesBookSnapshot = serde_json::from_str(json).unwrap();
558 let instrument = create_mock_perp();
559
560 let deltas = parse_futures_ws_book_snapshot_deltas(&snapshot, &instrument, 0, TS).unwrap();
561
562 assert_eq!(deltas.len(), 4);
564 assert_eq!(deltas[0].action, BookAction::Clear);
565 assert_eq!(deltas[1].order.side, OrderSide::Buy.into());
566 assert_eq!(deltas[1].order.price, Price::from("34892.5"));
567 assert_eq!(deltas[2].order.side, OrderSide::Buy.into());
568 assert_eq!(deltas[2].order.price, Price::from("34891.5"));
569 assert_eq!(deltas[3].order.side, OrderSide::Sell.into());
570 assert_eq!(deltas[3].order.price, Price::from("34912.0"));
571 assert_snapshot_delta_flags(instrument.id(), deltas);
572 }
573
574 #[rstest]
575 fn test_parse_futures_ws_book_snapshot_all_zero_qty_marks_clear_last() {
576 let json = include_str!("../../../test_data/ws_futures_book_snapshot.json");
577 let mut snapshot: KrakenFuturesBookSnapshot = serde_json::from_str(json).unwrap();
578 for level in snapshot.bids.iter_mut().chain(snapshot.asks.iter_mut()) {
579 level.qty = Decimal::ZERO;
580 }
581 let instrument = create_mock_perp();
582
583 let deltas = parse_futures_ws_book_snapshot_deltas(&snapshot, &instrument, 0, TS).unwrap();
584
585 assert_eq!(deltas.len(), 1);
586 assert_eq!(deltas[0].action, BookAction::Clear);
587 assert_eq!(
588 deltas[0].flags,
589 RecordFlag::F_SNAPSHOT as u8 | RecordFlag::F_LAST as u8
590 );
591 assert_snapshot_delta_flags(instrument.id(), deltas);
592 }
593
594 #[rstest]
595 fn test_parse_futures_ws_book_delta() {
596 let json = include_str!("../../../test_data/ws_futures_book_delta.json");
597 let delta_msg: KrakenFuturesBookDelta = serde_json::from_str(json).unwrap();
598 let instrument = create_mock_perp();
599
600 let delta = parse_futures_ws_book_delta(&delta_msg, &instrument, 10, TS).unwrap();
601
602 assert_eq!(delta.instrument_id, instrument.id());
603 assert_eq!(delta.order.side, OrderSide::Sell.into());
604 assert_eq!(delta.action, BookAction::Delete); assert_eq!(delta.sequence, 10);
606 assert!(RecordFlag::F_LAST.matches(delta.flags));
607 assert!(!RecordFlag::F_SNAPSHOT.matches(delta.flags));
608 }
609
610 #[rstest]
611 fn test_parse_futures_ws_order_status_report_new_order() {
612 let order = KrakenFuturesOpenOrder {
613 instrument: ustr::Ustr::from("PI_XBTUSD"),
614 time: 1700000000000,
615 last_update_time: 1700000000100,
616 qty: dec!(1000),
617 filled: Decimal::ZERO,
618 limit_price: Some(dec!(35000)),
619 stop_price: None,
620 order_type: KrakenFuturesOrderType::Limit,
621 order_id: "abc-123".to_string(),
622 cli_ord_id: Some("my-order-1".to_string()),
623 direction: 0,
624 reduce_only: false,
625 trigger_signal: None,
626 };
627 let instrument = create_mock_perp();
628 let account_id = AccountId::from("KRAKEN-001");
629
630 let report =
631 parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
632 .unwrap();
633
634 assert_eq!(report.order_status, OrderStatus::Accepted);
635 assert_eq!(report.order_side, OrderSide::Buy.into());
636 assert_eq!(report.order_type, OrderType::Limit);
637 assert_eq!(report.quantity.as_decimal(), dec!(1000));
638 assert_eq!(report.filled_qty.as_decimal(), Decimal::ZERO);
639 assert_eq!(report.price.unwrap().as_decimal(), dec!(35000));
640 }
641
642 #[rstest]
643 fn test_parse_futures_ws_order_status_report_fails_on_an_invalid_order_id() {
644 let order = KrakenFuturesOpenOrder {
645 instrument: ustr::Ustr::from("PI_XBTUSD"),
646 time: 1700000000000,
647 last_update_time: 1700000000100,
648 qty: dec!(1000),
649 filled: Decimal::ZERO,
650 limit_price: Some(dec!(35000)),
651 stop_price: None,
652 order_type: KrakenFuturesOrderType::Limit,
653 order_id: String::new(),
654 cli_ord_id: None,
655 direction: 0,
656 reduce_only: false,
657 trigger_signal: None,
658 };
659
660 let error = parse_futures_ws_order_status_report(
661 &order,
662 false,
663 None,
664 &create_mock_perp(),
665 AccountId::from("KRAKEN-001"),
666 TS,
667 )
668 .unwrap_err();
669
670 assert_eq!(
671 error.to_string(),
672 "Invalid order_id '' in Kraken futures order delta"
673 );
674 }
675
676 #[rstest]
678 fn test_parse_futures_ws_fill_report_names_the_fill_of_an_invalid_order_id() {
679 let json = include_str!("../../../test_data/ws_futures_fills_delta.json");
680 let fills_delta: super::super::messages::KrakenFuturesFillsDelta =
681 serde_json::from_str(json).unwrap();
682 let mut fill = fills_delta.fills[0].clone();
683 fill.order_id = String::new();
684
685 let error = parse_futures_ws_fill_report(
686 &fill,
687 &create_mock_perp(),
688 AccountId::from("KRAKEN-001"),
689 TS,
690 )
691 .unwrap_err();
692
693 assert_eq!(
694 error.to_string(),
695 format!(
696 "Invalid order_id '' in Kraken futures fill {}",
697 fill.fill_id
698 )
699 );
700 }
701
702 #[rstest]
703 fn test_parse_futures_ws_order_status_report_canceled() {
704 let order = KrakenFuturesOpenOrder {
705 instrument: ustr::Ustr::from("PI_XBTUSD"),
706 time: 1700000000000,
707 last_update_time: 1700000001000,
708 qty: dec!(1000),
709 filled: Decimal::ZERO,
710 limit_price: Some(dec!(35000)),
711 stop_price: None,
712 order_type: KrakenFuturesOrderType::Limit,
713 order_id: "abc-123".to_string(),
714 cli_ord_id: None,
715 direction: 1,
716 reduce_only: false,
717 trigger_signal: None,
718 };
719 let instrument = create_mock_perp();
720 let account_id = AccountId::from("KRAKEN-001");
721
722 let report = parse_futures_ws_order_status_report(
723 &order,
724 true,
725 Some("cancelled_by_user"),
726 &instrument,
727 account_id,
728 TS,
729 )
730 .unwrap();
731
732 assert_eq!(report.order_status, OrderStatus::Canceled);
733 assert_eq!(report.order_side, OrderSide::Sell.into());
734 assert_eq!(report.cancel_reason.as_deref(), Some("cancelled_by_user"));
735 }
736
737 #[rstest]
740 #[case::limit(KrakenFuturesOrderType::Limit, TimeInForce::Gtc, false)]
741 #[case::ioc(KrakenFuturesOrderType::Ioc, TimeInForce::Ioc, false)]
742 #[case::post(KrakenFuturesOrderType::Post, TimeInForce::Gtc, true)]
743 #[case::stop(KrakenFuturesOrderType::StopLower, TimeInForce::Gtc, false)]
744 #[case::take_profit(KrakenFuturesOrderType::TakeProfit, TimeInForce::Gtc, false)]
745 fn test_parse_futures_ws_order_status_report_time_in_force(
746 #[case] order_type: KrakenFuturesOrderType,
747 #[case] time_in_force: TimeInForce,
748 #[case] post_only: bool,
749 ) {
750 let order = KrakenFuturesOpenOrder {
751 instrument: ustr::Ustr::from("PI_XBTUSD"),
752 time: 1700000000000,
753 last_update_time: 1700000000100,
754 qty: dec!(1000),
755 filled: Decimal::ZERO,
756 limit_price: Some(dec!(35000)),
757 stop_price: None,
758 order_type,
759 order_id: "abc-123".to_string(),
760 cli_ord_id: None,
761 direction: 0,
762 reduce_only: false,
763 trigger_signal: None,
764 };
765
766 let report = parse_futures_ws_order_status_report(
767 &order,
768 false,
769 None,
770 &create_mock_perp(),
771 AccountId::from("KRAKEN-001"),
772 TS,
773 )
774 .unwrap();
775
776 assert_eq!(report.time_in_force, time_in_force);
777 assert_eq!(report.post_only, post_only);
778 }
779
780 #[rstest]
781 fn test_parse_futures_ws_order_status_report_market_if_touched() {
782 let order = KrakenFuturesOpenOrder {
783 instrument: ustr::Ustr::from("PI_XBTUSD"),
784 time: 1700000000000,
785 last_update_time: 1700000000100,
786 qty: dec!(500),
787 filled: Decimal::ZERO,
788 limit_price: None,
789 stop_price: Some(dec!(36000)),
790 order_type: KrakenFuturesOrderType::TakeProfit,
791 order_id: "tp-001".to_string(),
792 cli_ord_id: Some("my-tp-1".to_string()),
793 direction: 0,
794 reduce_only: true,
795 trigger_signal: None,
796 };
797 let instrument = create_mock_perp();
798 let account_id = AccountId::from("KRAKEN-001");
799
800 let report =
801 parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
802 .unwrap();
803
804 assert_eq!(report.order_type, OrderType::MarketIfTouched);
805 assert_eq!(report.trigger_price.unwrap().as_decimal(), dec!(36000));
806 assert!(report.price.is_none());
807 assert!(report.reduce_only);
808 }
809
810 #[rstest]
811 fn test_parse_futures_ws_order_status_report_limit_if_touched() {
812 let order = KrakenFuturesOpenOrder {
813 instrument: ustr::Ustr::from("PI_XBTUSD"),
814 time: 1700000000000,
815 last_update_time: 1700000000100,
816 qty: dec!(500),
817 filled: Decimal::ZERO,
818 limit_price: Some(dec!(35500)),
819 stop_price: Some(dec!(36000)),
820 order_type: KrakenFuturesOrderType::TakeProfit,
821 order_id: "tpl-001".to_string(),
822 cli_ord_id: Some("my-tpl-1".to_string()),
823 direction: 1,
824 reduce_only: false,
825 trigger_signal: None,
826 };
827 let instrument = create_mock_perp();
828 let account_id = AccountId::from("KRAKEN-001");
829
830 let report =
831 parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
832 .unwrap();
833
834 assert_eq!(report.order_type, OrderType::LimitIfTouched);
835 assert_eq!(report.trigger_price.unwrap().as_decimal(), dec!(36000));
836 assert_eq!(report.price.unwrap().as_decimal(), dec!(35500));
837 assert_eq!(report.order_side, OrderSide::Sell.into());
838 }
839
840 #[rstest]
841 fn test_parse_futures_ws_order_status_report_spot_trigger_signal() {
842 let order = KrakenFuturesOpenOrder {
843 instrument: ustr::Ustr::from("PI_XBTUSD"),
844 time: 1700000000000,
845 last_update_time: 1700000000100,
846 qty: dec!(500),
847 filled: Decimal::ZERO,
848 limit_price: None,
849 stop_price: Some(dec!(36000)),
850 order_type: KrakenFuturesOrderType::TakeProfit,
851 order_id: "tp-spot-001".to_string(),
852 cli_ord_id: Some("my-tp-spot-1".to_string()),
853 direction: 0,
854 reduce_only: false,
855 trigger_signal: Some("spot".to_string()),
856 };
857 let instrument = create_mock_perp();
858 let account_id = AccountId::from("KRAKEN-001");
859
860 let report =
861 parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
862 .unwrap();
863
864 assert_eq!(report.trigger_type, Some(TriggerType::IndexPrice));
865 }
866
867 #[rstest]
868 #[case::taker(KrakenFillType::Taker, LiquiditySide::Taker)]
869 #[case::assignee(KrakenFillType::Assignee, LiquiditySide::NoLiquiditySide)]
870 fn test_parse_futures_ws_fill_report(
871 #[case] fill_type: KrakenFillType,
872 #[case] expected_liquidity_side: LiquiditySide,
873 ) {
874 let json = include_str!("../../../test_data/ws_futures_fills_delta.json");
875 let fills_delta: super::super::messages::KrakenFuturesFillsDelta =
876 serde_json::from_str(json).unwrap();
877 let mut fill = fills_delta.fills[0].clone();
878 fill.fill_type = fill_type;
879
880 let instrument_id = InstrumentId::new(Symbol::new("PF_ETHUSD"), *KRAKEN_VENUE);
881 let usd = Currency::new("USD", 6, 0, "USD", CurrencyType::Fiat);
882 let instrument = InstrumentAny::CryptoPerpetual(
883 CryptoPerpetual::builder()
884 .instrument_id(instrument_id)
885 .raw_symbol(Symbol::new("PF_ETHUSD"))
886 .base_currency(Currency::ETH())
887 .quote_currency(usd)
888 .settlement_currency(usd)
889 .is_inverse(false)
890 .price_precision(1)
891 .size_precision(3)
892 .price_increment(Price::from("0.5"))
893 .size_increment(Quantity::from("0.001"))
894 .ts_event(TS)
895 .ts_init(TS)
896 .build()
897 .unwrap(),
898 );
899
900 let account_id = AccountId::from("KRAKEN-001");
901 let report = parse_futures_ws_fill_report(&fill, &instrument, account_id, TS).unwrap();
902
903 assert_eq!(report.instrument_id, instrument_id);
904 assert_eq!(report.order_side, OrderSide::Buy);
905 assert_eq!(report.last_px.as_decimal(), dec!(3162));
906 assert_eq!(report.last_qty.as_decimal(), dec!(0.001));
907 assert_eq!(report.liquidity_side, expected_liquidity_side);
908 assert_eq!(report.commission.as_decimal(), dec!(0.001581));
909 assert_eq!(report.commission.currency.code, "USD");
911 }
912
913 #[rstest]
918 fn test_parse_futures_ws_fill_report_honors_the_reported_fee_currency() {
919 let json = include_str!("../../../test_data/ws_futures_fills_delta.json");
920 let fills_delta: super::super::messages::KrakenFuturesFillsDelta =
921 serde_json::from_str(json).unwrap();
922 let mut fill = fills_delta.fills[0].clone();
923 fill.fee_currency = Some("XXBT".to_string());
924
925 let instrument_id = InstrumentId::new(Symbol::new("PI_XBTUSD"), *KRAKEN_VENUE);
926 let usd = Currency::new("USD", 6, 0, "USD", CurrencyType::Fiat);
927 let instrument = InstrumentAny::CryptoPerpetual(
928 CryptoPerpetual::builder()
929 .instrument_id(instrument_id)
930 .raw_symbol(Symbol::new("PI_XBTUSD"))
931 .base_currency(Currency::BTC())
932 .quote_currency(usd)
933 .settlement_currency(Currency::BTC())
934 .is_inverse(true)
935 .price_precision(1)
936 .size_precision(3)
937 .price_increment(Price::from("0.5"))
938 .size_increment(Quantity::from("0.001"))
939 .ts_event(TS)
940 .ts_init(TS)
941 .build()
942 .unwrap(),
943 );
944
945 let report =
946 parse_futures_ws_fill_report(&fill, &instrument, AccountId::from("KRAKEN-001"), TS)
947 .unwrap();
948
949 assert_eq!(report.commission.currency.code, "BTC");
951 assert_eq!(report.commission.as_decimal(), dec!(0.001581));
952 }
953}