nautilus_kraken/websocket/futures/
parse.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! WebSocket message parsers for converting Kraken Futures streaming data to Nautilus domain models.
17
18use 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, TimeInForce, TriggerType,
27    },
28    identifiers::{AccountId, ClientOrderId, TradeId, VenueOrderId},
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::enums::KrakenOrderSide;
40
41fn millis_to_nanos(millis: i64) -> UnixNanos {
42    UnixNanos::from((millis as u64) * NANOSECONDS_IN_MILLISECOND)
43}
44
45pub fn parse_futures_ws_quote_tick(
46    ticker: &KrakenFuturesTickerData,
47    instrument: &InstrumentAny,
48    ts_init: UnixNanos,
49) -> anyhow::Result<QuoteTick> {
50    let price_precision = instrument.price_precision();
51    let size_precision = instrument.size_precision();
52
53    let bid = ticker.bid.context("Ticker missing bid")?;
54    let ask = ticker.ask.context("Ticker missing ask")?;
55    let bid_size = ticker.bid_size.unwrap_or(Decimal::ZERO);
56    let ask_size = ticker.ask_size.unwrap_or(Decimal::ZERO);
57
58    let bid_price =
59        Price::from_decimal_dp(bid, price_precision).context("Failed to construct bid Price")?;
60    let ask_price =
61        Price::from_decimal_dp(ask, price_precision).context("Failed to construct ask Price")?;
62    let bid_qty = Quantity::from_decimal_dp(bid_size, size_precision)
63        .context("Failed to construct bid Quantity")?;
64    let ask_qty = Quantity::from_decimal_dp(ask_size, size_precision)
65        .context("Failed to construct ask Quantity")?;
66
67    let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
68
69    Ok(QuoteTick::new(
70        instrument.id(),
71        bid_price,
72        ask_price,
73        bid_qty,
74        ask_qty,
75        ts_event,
76        ts_init,
77    ))
78}
79
80pub fn parse_futures_ws_trade_tick(
81    trade: &KrakenFuturesTradeData,
82    instrument: &InstrumentAny,
83    ts_init: UnixNanos,
84) -> anyhow::Result<TradeTick> {
85    let price_precision = instrument.price_precision();
86    let size_precision = instrument.size_precision();
87
88    let price = Price::from_decimal_dp(trade.price, price_precision)
89        .context("Failed to construct trade Price")?;
90    let size = Quantity::from_decimal_dp(trade.qty, size_precision)
91        .context("Failed to construct trade Quantity")?;
92
93    let aggressor = match trade.side {
94        KrakenOrderSide::Buy => AggressorSide::Buy,
95        KrakenOrderSide::Sell => AggressorSide::Sell,
96    };
97
98    let trade_id = trade
99        .uid
100        .as_deref()
101        .map_or_else(|| TradeId::new(trade.seq.to_string()), TradeId::new);
102
103    let ts_event = millis_to_nanos(trade.time);
104
105    TradeTick::new_checked(
106        instrument.id(),
107        price,
108        size,
109        aggressor,
110        trade_id,
111        ts_event,
112        ts_init,
113    )
114    .context("Failed to construct TradeTick from Kraken futures trade")
115}
116
117pub fn parse_futures_ws_book_snapshot_deltas(
118    snapshot: &KrakenFuturesBookSnapshot,
119    instrument: &InstrumentAny,
120    sequence: u64,
121    ts_init: UnixNanos,
122) -> anyhow::Result<Vec<OrderBookDelta>> {
123    let instrument_id = instrument.id();
124    let price_precision = instrument.price_precision();
125    let size_precision = instrument.size_precision();
126    let ts_event = millis_to_nanos(snapshot.timestamp);
127
128    let capacity = snapshot.bids.len() + snapshot.asks.len() + 1;
129    let mut deltas = Vec::with_capacity(capacity);
130    let mut seq = sequence;
131
132    // Leading CLEAR delta to reset the book
133    deltas.push(OrderBookDelta::clear(instrument_id, seq, ts_event, ts_init));
134    seq += 1;
135
136    for level in &snapshot.bids {
137        if level.qty <= Decimal::ZERO {
138            continue;
139        }
140        let price = Price::from_decimal_dp(level.price, price_precision)?;
141        let size = Quantity::from_decimal_dp(level.qty, size_precision)?;
142        let order_id = price.raw() as u64;
143
144        let order = BookOrder::new(OrderSide::Buy, price, size, order_id);
145        deltas.push(OrderBookDelta::new(
146            instrument_id,
147            BookAction::Add,
148            order,
149            0,
150            seq,
151            ts_event,
152            ts_init,
153        ));
154        seq += 1;
155    }
156
157    for level in &snapshot.asks {
158        if level.qty <= Decimal::ZERO {
159            continue;
160        }
161        let price = Price::from_decimal_dp(level.price, price_precision)?;
162        let size = Quantity::from_decimal_dp(level.qty, size_precision)?;
163        let order_id = price.raw() as u64;
164
165        let order = BookOrder::new(OrderSide::Sell, price, size, order_id);
166        deltas.push(OrderBookDelta::new(
167            instrument_id,
168            BookAction::Add,
169            order,
170            0,
171            seq,
172            ts_event,
173            ts_init,
174        ));
175        seq += 1;
176    }
177
178    Ok(deltas)
179}
180
181pub fn parse_futures_ws_book_delta(
182    delta: &KrakenFuturesBookDelta,
183    instrument: &InstrumentAny,
184    sequence: u64,
185    ts_init: UnixNanos,
186) -> anyhow::Result<OrderBookDelta> {
187    let price_precision = instrument.price_precision();
188    let size_precision = instrument.size_precision();
189
190    let price = Price::from_decimal_dp(delta.price, price_precision)?;
191    let size = Quantity::from_decimal_dp(delta.qty, size_precision)?;
192
193    let action = if size.is_zero() {
194        BookAction::Delete
195    } else {
196        BookAction::Update
197    };
198
199    let side = match delta.side {
200        KrakenOrderSide::Buy => OrderSide::Buy,
201        KrakenOrderSide::Sell => OrderSide::Sell,
202    };
203
204    let order_id = price.raw() as u64;
205
206    let order = BookOrder::new(side, price, size, order_id);
207    let ts_event = millis_to_nanos(delta.timestamp);
208
209    Ok(OrderBookDelta::new(
210        instrument.id(),
211        action,
212        order,
213        0,
214        sequence,
215        ts_event,
216        ts_init,
217    ))
218}
219
220fn parse_ws_direction(direction: i32) -> OrderSide {
221    if direction == 0 {
222        OrderSide::Buy
223    } else {
224        OrderSide::Sell
225    }
226}
227
228fn infer_order_status(order: &KrakenFuturesOpenOrder, is_cancel: bool) -> OrderStatus {
229    if order.filled >= order.qty && order.qty > Decimal::ZERO {
230        OrderStatus::Filled
231    } else if is_cancel {
232        OrderStatus::Canceled
233    } else if order.filled > Decimal::ZERO {
234        OrderStatus::PartiallyFilled
235    } else {
236        OrderStatus::Accepted
237    }
238}
239
240pub fn parse_futures_ws_order_status_report(
241    order: &KrakenFuturesOpenOrder,
242    is_cancel: bool,
243    reason: Option<&str>,
244    instrument: &InstrumentAny,
245    account_id: AccountId,
246    ts_init: UnixNanos,
247) -> anyhow::Result<OrderStatusReport> {
248    let venue_order_id = VenueOrderId::new(&order.order_id);
249    let order_side = parse_ws_direction(order.direction);
250    let order_type = OrderType::from(order.order_type);
251    let order_type = if order_type == OrderType::MarketIfTouched && order.limit_price.is_some() {
252        OrderType::LimitIfTouched
253    } else {
254        order_type
255    };
256    let order_status = infer_order_status(order, is_cancel);
257
258    let price_precision = instrument.price_precision();
259    let size_precision = instrument.size_precision();
260
261    let quantity = Quantity::from_decimal_dp(order.qty, size_precision)
262        .context("Failed to parse order qty")?;
263    let filled_qty = Quantity::from_decimal_dp(order.filled, size_precision)
264        .context("Failed to parse order filled")?;
265
266    let ts_accepted = millis_to_nanos(order.time);
267    let ts_last = millis_to_nanos(order.last_update_time);
268
269    let mut report = OrderStatusReport {
270        account_id,
271        instrument_id: instrument.id(),
272        client_order_id: order.cli_ord_id.as_ref().map(ClientOrderId::new),
273        venue_order_id,
274        order_side: order_side.into(),
275        order_type,
276        time_in_force: TimeInForce::Gtc,
277        order_status,
278        quantity,
279        filled_qty,
280        report_id: UUID4::new(),
281        ts_accepted,
282        ts_last,
283        ts_init,
284        order_list_id: None,
285        venue_position_id: None,
286        linked_order_ids: None,
287        parent_order_id: None,
288        contingency_type: None,
289        expire_time: None,
290        price: None,
291        activation_price: None,
292        trigger_price: None,
293        trigger_type: None,
294        limit_offset: None,
295        trailing_offset: None,
296        trailing_offset_type: None,
297        display_qty: None,
298        avg_px: None,
299        post_only: false,
300        reduce_only: order.reduce_only,
301        cancel_reason: None,
302        ts_triggered: None,
303    };
304
305    if let Some(px) = order.limit_price {
306        report.price = Some(Price::from_decimal_dp(px, price_precision)?);
307    }
308
309    if let Some(px) = order.stop_price {
310        report.trigger_price = Some(Price::from_decimal_dp(px, price_precision)?);
311        report.trigger_type = Some(order.trigger_signal.as_deref().map_or(
312            TriggerType::Default,
313            |s| match s {
314                "mark" | "mark_price" => TriggerType::MarkPrice,
315                "spot" | "spot_price" | "index" | "index_price" => TriggerType::IndexPrice,
316                _ => TriggerType::LastPrice,
317            },
318        ));
319    }
320
321    if let Some(reason) = reason
322        && !reason.is_empty()
323    {
324        report.cancel_reason = Some(reason.to_string());
325    }
326
327    Ok(report)
328}
329
330pub fn parse_futures_ws_fill_report(
331    fill: &KrakenFuturesFill,
332    instrument: &InstrumentAny,
333    account_id: AccountId,
334    ts_init: UnixNanos,
335) -> anyhow::Result<FillReport> {
336    let price_precision = instrument.price_precision();
337    let size_precision = instrument.size_precision();
338
339    let venue_order_id = VenueOrderId::new(&fill.order_id);
340    let trade_id = TradeId::new(&fill.fill_id);
341    let order_side = if fill.buy {
342        OrderSide::Buy
343    } else {
344        OrderSide::Sell
345    };
346
347    let last_qty =
348        Quantity::from_decimal_dp(fill.qty, size_precision).context("Failed to parse fill qty")?;
349    let last_px = Price::from_decimal_dp(fill.price, price_precision)
350        .context("Failed to parse fill price")?;
351
352    let liquidity_side = fill.fill_type.into();
353
354    let fee = fill.fee_paid.unwrap_or(Decimal::ZERO);
355    let commission_currency = instrument.quote_currency();
356    let commission = Money::from_decimal(fee, commission_currency)?;
357
358    let ts_event = millis_to_nanos(fill.time);
359
360    let client_order_id = fill
361        .cli_ord_id
362        .as_ref()
363        .filter(|s| !s.is_empty())
364        .map(ClientOrderId::new);
365
366    Ok(FillReport::new(
367        account_id,
368        instrument.id(),
369        venue_order_id,
370        trade_id,
371        order_side,
372        last_qty,
373        last_px,
374        commission,
375        liquidity_side,
376        client_order_id,
377        None, // venue_position_id
378        ts_event,
379        ts_init,
380        None, // report_id
381    ))
382}
383
384pub fn parse_futures_ws_mark_price(
385    ticker: &KrakenFuturesTickerData,
386    instrument: &InstrumentAny,
387    ts_init: UnixNanos,
388) -> Option<MarkPriceUpdate> {
389    let mark_price = ticker.mark_price?;
390    let price = Price::from_decimal_dp(mark_price, instrument.price_precision()).ok()?;
391    let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
392    Some(MarkPriceUpdate::new(
393        instrument.id(),
394        price,
395        ts_event,
396        ts_init,
397    ))
398}
399
400pub fn parse_futures_ws_index_price(
401    ticker: &KrakenFuturesTickerData,
402    instrument: &InstrumentAny,
403    ts_init: UnixNanos,
404) -> Option<IndexPriceUpdate> {
405    let index = ticker.index?;
406    let price = Price::from_decimal_dp(index, instrument.price_precision()).ok()?;
407    let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
408    Some(IndexPriceUpdate::new(
409        instrument.id(),
410        price,
411        ts_event,
412        ts_init,
413    ))
414}
415
416pub fn parse_futures_ws_funding_rate(
417    ticker: &KrakenFuturesTickerData,
418    instrument: &InstrumentAny,
419    ts_init: UnixNanos,
420) -> Option<FundingRateUpdate> {
421    let rate = ticker.relative_funding_rate?;
422    let ts_event = ticker.time.map_or(ts_init, millis_to_nanos);
423    let next_funding_ns = ticker
424        .next_funding_rate_time
425        .map(|t| millis_to_nanos(t as i64));
426    Some(FundingRateUpdate::new(
427        instrument.id(),
428        rate,
429        None,
430        next_funding_ns,
431        ts_event,
432        ts_init,
433    ))
434}
435
436#[cfg(test)]
437mod tests {
438    use nautilus_model::{
439        enums::{CurrencyType, LiquiditySide, OrderSide},
440        identifiers::{InstrumentId, Symbol},
441        instruments::crypto_perpetual::CryptoPerpetual,
442        types::Currency,
443    };
444    use rstest::rstest;
445    use rust_decimal_macros::dec;
446
447    use super::*;
448    use crate::common::{
449        consts::KRAKEN_VENUE,
450        enums::{KrakenFillType, KrakenFuturesOrderType},
451    };
452
453    const TS: UnixNanos = UnixNanos::new(1_700_000_000_000_000_000);
454
455    fn create_mock_perp() -> InstrumentAny {
456        let instrument_id = InstrumentId::new(Symbol::new("PI_XBTUSD"), *KRAKEN_VENUE);
457        InstrumentAny::CryptoPerpetual(
458            CryptoPerpetual::builder()
459                .instrument_id(instrument_id)
460                .raw_symbol(Symbol::new("PI_XBTUSD"))
461                .base_currency(Currency::BTC())
462                .quote_currency(Currency::USD())
463                .settlement_currency(Currency::USD())
464                .is_inverse(false)
465                .price_precision(1)
466                .size_precision(0)
467                .price_increment(Price::from("0.5"))
468                .size_increment(Quantity::from("1"))
469                .ts_event(TS)
470                .ts_init(TS)
471                .build()
472                .unwrap(),
473        )
474    }
475
476    #[rstest]
477    fn test_parse_futures_ws_quote_tick() {
478        let json = include_str!("../../../test_data/ws_futures_ticker.json");
479        let ticker: KrakenFuturesTickerData = serde_json::from_str(json).unwrap();
480        let instrument = create_mock_perp();
481
482        let quote = parse_futures_ws_quote_tick(&ticker, &instrument, TS).unwrap();
483
484        assert_eq!(quote.instrument_id, instrument.id());
485        assert_eq!(quote.bid_price, Price::from("21978.5"));
486        assert_eq!(quote.ask_price, Price::from("21987.0"));
487        assert_eq!(quote.bid_size, Quantity::from("2536.0"));
488        assert_eq!(quote.ask_size, Quantity::from("13948.0"));
489    }
490
491    #[rstest]
492    fn test_parse_futures_ws_trade_tick() {
493        let json = include_str!("../../../test_data/ws_futures_trade.json");
494        let trade: KrakenFuturesTradeData = serde_json::from_str(json).unwrap();
495        let instrument = create_mock_perp();
496
497        let tick = parse_futures_ws_trade_tick(&trade, &instrument, TS).unwrap();
498
499        assert_eq!(tick.instrument_id, instrument.id());
500        assert_eq!(tick.price, Price::from("34969.5"));
501        assert_eq!(tick.size, Quantity::from("15000.0"));
502        assert_eq!(tick.aggressor_side, AggressorSide::Sell);
503    }
504
505    #[rstest]
506    fn test_parse_futures_ws_book_snapshot() {
507        let json = include_str!("../../../test_data/ws_futures_book_snapshot.json");
508        let snapshot: KrakenFuturesBookSnapshot = serde_json::from_str(json).unwrap();
509        let instrument = create_mock_perp();
510
511        let deltas = parse_futures_ws_book_snapshot_deltas(&snapshot, &instrument, 0, TS).unwrap();
512
513        // CLEAR + 2 bids + 2 asks = 5
514        assert_eq!(deltas.len(), 5);
515        assert_eq!(deltas[0].action, BookAction::Clear);
516        assert_eq!(deltas[1].action, BookAction::Add);
517        assert_eq!(deltas[1].order.side, OrderSide::Buy.into());
518        assert_eq!(deltas[3].order.side, OrderSide::Sell.into());
519    }
520
521    #[rstest]
522    fn test_parse_futures_ws_book_snapshot_skips_zero_qty() {
523        let json = include_str!("../../../test_data/ws_futures_book_snapshot_with_zero_qty.json");
524        let snapshot: KrakenFuturesBookSnapshot = serde_json::from_str(json).unwrap();
525        let instrument = create_mock_perp();
526
527        let deltas = parse_futures_ws_book_snapshot_deltas(&snapshot, &instrument, 0, TS).unwrap();
528
529        // CLEAR + 2 bids (skipped qty=0) + 1 ask (skipped qty=0) = 4
530        assert_eq!(deltas.len(), 4);
531        assert_eq!(deltas[0].action, BookAction::Clear);
532        assert_eq!(deltas[1].order.side, OrderSide::Buy.into());
533        assert_eq!(deltas[1].order.price, Price::from("34892.5"));
534        assert_eq!(deltas[2].order.side, OrderSide::Buy.into());
535        assert_eq!(deltas[2].order.price, Price::from("34891.5"));
536        assert_eq!(deltas[3].order.side, OrderSide::Sell.into());
537        assert_eq!(deltas[3].order.price, Price::from("34912.0"));
538    }
539
540    #[rstest]
541    fn test_parse_futures_ws_book_delta() {
542        let json = include_str!("../../../test_data/ws_futures_book_delta.json");
543        let delta_msg: KrakenFuturesBookDelta = serde_json::from_str(json).unwrap();
544        let instrument = create_mock_perp();
545
546        let delta = parse_futures_ws_book_delta(&delta_msg, &instrument, 10, TS).unwrap();
547
548        assert_eq!(delta.instrument_id, instrument.id());
549        assert_eq!(delta.order.side, OrderSide::Sell.into());
550        assert_eq!(delta.action, BookAction::Delete); // qty=0
551        assert_eq!(delta.sequence, 10);
552    }
553
554    #[rstest]
555    fn test_parse_futures_ws_order_status_report_new_order() {
556        let order = KrakenFuturesOpenOrder {
557            instrument: ustr::Ustr::from("PI_XBTUSD"),
558            time: 1700000000000,
559            last_update_time: 1700000000100,
560            qty: dec!(1000),
561            filled: Decimal::ZERO,
562            limit_price: Some(dec!(35000)),
563            stop_price: None,
564            order_type: KrakenFuturesOrderType::Limit,
565            order_id: "abc-123".to_string(),
566            cli_ord_id: Some("my-order-1".to_string()),
567            direction: 0,
568            reduce_only: false,
569            trigger_signal: None,
570        };
571        let instrument = create_mock_perp();
572        let account_id = AccountId::from("KRAKEN-001");
573
574        let report =
575            parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
576                .unwrap();
577
578        assert_eq!(report.order_status, OrderStatus::Accepted);
579        assert_eq!(report.order_side, OrderSide::Buy.into());
580        assert_eq!(report.order_type, OrderType::Limit);
581        assert_eq!(report.quantity.as_decimal(), dec!(1000));
582        assert_eq!(report.filled_qty.as_decimal(), Decimal::ZERO);
583        assert_eq!(report.price.unwrap().as_decimal(), dec!(35000));
584    }
585
586    #[rstest]
587    fn test_parse_futures_ws_order_status_report_canceled() {
588        let order = KrakenFuturesOpenOrder {
589            instrument: ustr::Ustr::from("PI_XBTUSD"),
590            time: 1700000000000,
591            last_update_time: 1700000001000,
592            qty: dec!(1000),
593            filled: Decimal::ZERO,
594            limit_price: Some(dec!(35000)),
595            stop_price: None,
596            order_type: KrakenFuturesOrderType::Limit,
597            order_id: "abc-123".to_string(),
598            cli_ord_id: None,
599            direction: 1,
600            reduce_only: false,
601            trigger_signal: None,
602        };
603        let instrument = create_mock_perp();
604        let account_id = AccountId::from("KRAKEN-001");
605
606        let report = parse_futures_ws_order_status_report(
607            &order,
608            true,
609            Some("cancelled_by_user"),
610            &instrument,
611            account_id,
612            TS,
613        )
614        .unwrap();
615
616        assert_eq!(report.order_status, OrderStatus::Canceled);
617        assert_eq!(report.order_side, OrderSide::Sell.into());
618        assert_eq!(report.cancel_reason.as_deref(), Some("cancelled_by_user"));
619    }
620
621    #[rstest]
622    fn test_parse_futures_ws_order_status_report_market_if_touched() {
623        let order = KrakenFuturesOpenOrder {
624            instrument: ustr::Ustr::from("PI_XBTUSD"),
625            time: 1700000000000,
626            last_update_time: 1700000000100,
627            qty: dec!(500),
628            filled: Decimal::ZERO,
629            limit_price: None,
630            stop_price: Some(dec!(36000)),
631            order_type: KrakenFuturesOrderType::TakeProfit,
632            order_id: "tp-001".to_string(),
633            cli_ord_id: Some("my-tp-1".to_string()),
634            direction: 0,
635            reduce_only: true,
636            trigger_signal: None,
637        };
638        let instrument = create_mock_perp();
639        let account_id = AccountId::from("KRAKEN-001");
640
641        let report =
642            parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
643                .unwrap();
644
645        assert_eq!(report.order_type, OrderType::MarketIfTouched);
646        assert_eq!(report.trigger_price.unwrap().as_decimal(), dec!(36000));
647        assert!(report.price.is_none());
648        assert!(report.reduce_only);
649    }
650
651    #[rstest]
652    fn test_parse_futures_ws_order_status_report_limit_if_touched() {
653        let order = KrakenFuturesOpenOrder {
654            instrument: ustr::Ustr::from("PI_XBTUSD"),
655            time: 1700000000000,
656            last_update_time: 1700000000100,
657            qty: dec!(500),
658            filled: Decimal::ZERO,
659            limit_price: Some(dec!(35500)),
660            stop_price: Some(dec!(36000)),
661            order_type: KrakenFuturesOrderType::TakeProfit,
662            order_id: "tpl-001".to_string(),
663            cli_ord_id: Some("my-tpl-1".to_string()),
664            direction: 1,
665            reduce_only: false,
666            trigger_signal: None,
667        };
668        let instrument = create_mock_perp();
669        let account_id = AccountId::from("KRAKEN-001");
670
671        let report =
672            parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
673                .unwrap();
674
675        assert_eq!(report.order_type, OrderType::LimitIfTouched);
676        assert_eq!(report.trigger_price.unwrap().as_decimal(), dec!(36000));
677        assert_eq!(report.price.unwrap().as_decimal(), dec!(35500));
678        assert_eq!(report.order_side, OrderSide::Sell.into());
679    }
680
681    #[rstest]
682    fn test_parse_futures_ws_order_status_report_spot_trigger_signal() {
683        let order = KrakenFuturesOpenOrder {
684            instrument: ustr::Ustr::from("PI_XBTUSD"),
685            time: 1700000000000,
686            last_update_time: 1700000000100,
687            qty: dec!(500),
688            filled: Decimal::ZERO,
689            limit_price: None,
690            stop_price: Some(dec!(36000)),
691            order_type: KrakenFuturesOrderType::TakeProfit,
692            order_id: "tp-spot-001".to_string(),
693            cli_ord_id: Some("my-tp-spot-1".to_string()),
694            direction: 0,
695            reduce_only: false,
696            trigger_signal: Some("spot".to_string()),
697        };
698        let instrument = create_mock_perp();
699        let account_id = AccountId::from("KRAKEN-001");
700
701        let report =
702            parse_futures_ws_order_status_report(&order, false, None, &instrument, account_id, TS)
703                .unwrap();
704
705        assert_eq!(report.trigger_type, Some(TriggerType::IndexPrice));
706    }
707
708    #[rstest]
709    #[case::taker(KrakenFillType::Taker, LiquiditySide::Taker)]
710    #[case::assignee(KrakenFillType::Assignee, LiquiditySide::NoLiquiditySide)]
711    fn test_parse_futures_ws_fill_report(
712        #[case] fill_type: KrakenFillType,
713        #[case] expected_liquidity_side: LiquiditySide,
714    ) {
715        let json = include_str!("../../../test_data/ws_futures_fills_delta.json");
716        let fills_delta: super::super::messages::KrakenFuturesFillsDelta =
717            serde_json::from_str(json).unwrap();
718        let mut fill = fills_delta.fills[0].clone();
719        fill.fill_type = fill_type;
720
721        let instrument_id = InstrumentId::new(Symbol::new("PF_ETHUSD"), *KRAKEN_VENUE);
722        let usd = Currency::new("USD", 6, 0, "USD", CurrencyType::Fiat);
723        let instrument = InstrumentAny::CryptoPerpetual(
724            CryptoPerpetual::builder()
725                .instrument_id(instrument_id)
726                .raw_symbol(Symbol::new("PF_ETHUSD"))
727                .base_currency(Currency::ETH())
728                .quote_currency(usd)
729                .settlement_currency(usd)
730                .is_inverse(false)
731                .price_precision(1)
732                .size_precision(3)
733                .price_increment(Price::from("0.5"))
734                .size_increment(Quantity::from("0.001"))
735                .ts_event(TS)
736                .ts_init(TS)
737                .build()
738                .unwrap(),
739        );
740
741        let account_id = AccountId::from("KRAKEN-001");
742        let report = parse_futures_ws_fill_report(&fill, &instrument, account_id, TS).unwrap();
743
744        assert_eq!(report.instrument_id, instrument_id);
745        assert_eq!(report.order_side, OrderSide::Buy);
746        assert_eq!(report.last_px.as_decimal(), dec!(3162));
747        assert_eq!(report.last_qty.as_decimal(), dec!(0.001));
748        assert_eq!(report.liquidity_side, expected_liquidity_side);
749        assert_eq!(report.commission.as_decimal(), dec!(0.001581));
750    }
751}
nautilus_kraken/websocket/futures/parse.rs

nautilus_kraken/websocket/futures/
parse.rs
