Skip to main content

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, 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    // Leading CLEAR delta to reset the book
136    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    // The venue reports the fee currency, which on an inverse contract is not the quote.
367    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, // venue_position_id
393        ts_event,
394        ts_init,
395        None, // report_id
396    ))
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        // CLEAR + 2 bids + 2 asks = 5
546        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        // CLEAR + 2 bids (skipped qty=0) + 1 ask (skipped qty=0) = 4
563        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); // qty=0
605        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    /// The dispatch logs only this message for the fill it drops, so the message names the fill.
677    #[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    /// The `ioc` and `post` types reach the report as `IOC` and post-only `GTC`, and any other type
738    /// stays `GTC` and not post-only.
739    #[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        // The fixture reports the quote currency, so the commission stays in it.
910        assert_eq!(report.commission.currency.code, "USD");
911    }
912
913    /// A fee the venue reports in something other than the quote must be booked in that currency.
914    ///
915    /// An inverse contract charges in the base currency, so assuming the quote would record the
916    /// wrong currency against the amount.
917    #[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        // `XXBT` is Kraken's spelling; the report carries the standard code.
950        assert_eq!(report.commission.currency.code, "BTC");
951        assert_eq!(report.commission.as_decimal(), dec!(0.001581));
952    }
953}