Skip to main content

nautilus_kalshi/execution/
reports.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
16use anyhow::Context;
17use nautilus_core::{UnixNanos, datetime::try_datetime_to_unix_nanos};
18use nautilus_model::{
19    enums::{LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide, TimeInForce},
20    events::OrderEventAny,
21    identifiers::{AccountId, ClientOrderId, TradeId, VenueOrderId},
22    instruments::BinaryOption,
23    orders::{Order, OrderAny},
24    reports::{FillReport, OrderStatusReport, PositionStatusReport},
25    types::{Currency, Money, Quantity},
26};
27use rust_decimal::Decimal;
28
29use super::timestamp;
30use crate::{
31    common::{enums::OrderType as VenueOrderType, parse::parse_instrument_id},
32    data::parse::{price, size},
33    http::models::{
34        BookSide, Field, Fill, FixedPoint, MarketPosition, Order as VenueOrder,
35        OrderStatus as VenueOrderStatus, OutcomeSide,
36    },
37};
38
39/// Builds an order-status report from one venue order.
40///
41/// Returns `Ok(None)` when a canceled order has no cached quantity to preserve, or the cached order
42/// is not closed with the same last time and filled count.
43///
44/// # Errors
45///
46/// Returns an error if identity, direction, type, status, counts, prices, or timestamps are invalid.
47pub fn order(
48    value: &VenueOrder,
49    instrument: &BinaryOption,
50    account_id: AccountId,
51    cached: Option<&OrderAny>,
52    ts_init: UnixNanos,
53) -> anyhow::Result<Option<OrderStatusReport>> {
54    order_inner(value, instrument, account_id, cached, ts_init, false)
55}
56
57pub(super) fn order_aggregate(
58    value: &VenueOrder,
59    instrument: &BinaryOption,
60    account_id: AccountId,
61    cached: &OrderAny,
62    ts_init: UnixNanos,
63) -> anyhow::Result<Option<OrderStatusReport>> {
64    order_inner(value, instrument, account_id, Some(cached), ts_init, true)
65}
66
67fn order_inner(
68    value: &VenueOrder,
69    instrument: &BinaryOption,
70    account_id: AccountId,
71    cached: Option<&OrderAny>,
72    ts_init: UnixNanos,
73    allow_post_only_rejection: bool,
74) -> anyhow::Result<Option<OrderStatusReport>> {
75    anyhow::ensure!(
76        parse_instrument_id(&value.ticker)? == instrument.id,
77        "order instrument mismatch"
78    );
79    anyhow::ensure!(
80        value.order_type == VenueOrderType::Limit,
81        "unsupported Kalshi order type"
82    );
83    let side = direction(value.book_side, value.outcome_side)?;
84    let px = price(value.yes_price_dollars, instrument.price_precision)?;
85    complementary(value.yes_price_dollars, value.no_price_dollars)?;
86    let filled = quantity(value.fill_count_fp, instrument.size_precision)?;
87    let remaining = quantity(value.remaining_count_fp, instrument.size_precision)?;
88    let ts_accepted = timestamp(&value.created_time)?;
89    let ts_last = timestamp(&value.last_update_time)?;
90    anyhow::ensure!(ts_last >= ts_accepted, "order timestamps out of sequence");
91    let venue_order_id = VenueOrderId::new_checked(&value.order_id)?;
92    let client_order_id = client_id(&value.client_order_id)?;
93    let total = value
94        .fill_count_fp
95        .0
96        .checked_add(value.remaining_count_fp.0)
97        .context("order total overflow")?;
98
99    let status = match value.status {
100        VenueOrderStatus::Resting => {
101            anyhow::ensure!(
102                remaining.is_positive(),
103                "resting order has no remaining quantity"
104            );
105
106            if filled.is_zero() {
107                OrderStatus::Accepted
108            } else {
109                OrderStatus::PartiallyFilled
110            }
111        }
112        VenueOrderStatus::Executed => {
113            anyhow::ensure!(
114                remaining.is_zero() && !filled.is_zero(),
115                "invalid executed order counts"
116            );
117            OrderStatus::Filled
118        }
119        VenueOrderStatus::Canceled => OrderStatus::Canceled,
120        VenueOrderStatus::Unknown => anyhow::bail!("unknown Kalshi order status"),
121    };
122
123    let expire_time = match value.expiration_time {
124        Field::Value(value) => {
125            Some(try_datetime_to_unix_nanos(value)?).filter(|value| *value != UnixNanos::default())
126        }
127        Field::Missing | Field::Null => None,
128    };
129
130    if let Some(cached) = cached {
131        anyhow::ensure!(
132            cached.instrument_id() == instrument.id
133                && cached.order_type() == OrderType::Limit
134                && cached.order_side() == side,
135            "cached order identity or direction mismatch"
136        );
137        anyhow::ensure!(
138            cached.account_id().is_none_or(|id| id == account_id),
139            "cached order account mismatch"
140        );
141        anyhow::ensure!(
142            cached
143                .venue_order_id()
144                .is_none_or(|id| id == venue_order_id),
145            "cached venue order identity mismatch"
146        );
147        anyhow::ensure!(
148            client_order_id.is_none_or(|id| id == cached.client_order_id()),
149            "cached client order identity mismatch"
150        );
151    }
152
153    let (quantity, status) = if value.status == VenueOrderStatus::Canceled {
154        let Some(state) = canceled_order_state(cached, filled, ts_last, allow_post_only_rejection)
155        else {
156            return Ok(None);
157        };
158
159        state
160    } else {
161        (
162            quantity(FixedPoint(total), instrument.size_precision)?,
163            status,
164        )
165    };
166
167    anyhow::ensure!(
168        quantity.is_positive() && filled <= quantity,
169        "invalid order total or filled count"
170    );
171
172    let default_tif = if expire_time.is_some() {
173        TimeInForce::Gtd
174    } else {
175        TimeInForce::Gtc
176    };
177
178    let time_in_force = cached.map_or(default_tif, Order::time_in_force);
179    anyhow::ensure!(
180        (time_in_force == TimeInForce::Gtd) == expire_time.is_some(),
181        "order expiration and command time in force disagree"
182    );
183
184    let mut report = OrderStatusReport::new(
185        account_id,
186        instrument.id,
187        cached.map(Order::client_order_id).or(client_order_id),
188        venue_order_id,
189        Some(side),
190        OrderType::Limit,
191        time_in_force,
192        status,
193        quantity,
194        filled,
195        ts_accepted,
196        ts_last,
197        ts_init,
198        None,
199    );
200
201    report.price = Some(px);
202    report.expire_time = expire_time;
203    if let Some(cached) = cached {
204        report.post_only = cached.is_post_only();
205        report.reduce_only = cached.is_reduce_only();
206        report.order_list_id = cached.order_list_id();
207    }
208
209    Ok(Some(report))
210}
211
212fn canceled_order_state(
213    cached: Option<&OrderAny>,
214    filled: Quantity,
215    ts_last: UnixNanos,
216    allow_post_only_rejection: bool,
217) -> Option<(Quantity, OrderStatus)> {
218    let cached = cached?;
219    let post_only_rejection = allow_post_only_rejection
220        && cached.status() == OrderStatus::Rejected
221        && cached.is_post_only()
222        && filled.is_zero()
223        && cached
224            .events()
225            .iter()
226            .any(|event| matches!(event, OrderEventAny::Rejected(event) if event.due_post_only));
227
228    if !cached.is_closed()
229        || cached.ts_last() != ts_last && !post_only_rejection
230        || cached.filled_qty() != filled
231    {
232        return None;
233    }
234
235    let status = if post_only_rejection {
236        OrderStatus::Rejected
237    } else {
238        OrderStatus::Canceled
239    };
240
241    Some((cached.quantity(), status))
242}
243
244/// Builds a fill report from one venue fill and its order.
245///
246/// The report preserves the venue price, count, and fee. It does not apply the fill to an order.
247///
248/// # Errors
249///
250/// Returns an error if the fill and order identities or directions disagree, prices are not
251/// complementary, or the count or fee is invalid.
252pub fn fill(
253    value: &Fill,
254    instrument: &BinaryOption,
255    account_id: AccountId,
256    order: &VenueOrder,
257    ts_init: UnixNanos,
258) -> anyhow::Result<FillReport> {
259    anyhow::ensure!(
260        parse_instrument_id(&value.ticker)? == instrument.id
261            && value.market_ticker == value.ticker
262            && order.ticker == value.ticker
263            && order.order_id == value.order_id,
264        "fill order or instrument identity mismatch"
265    );
266    let side = direction(value.book_side, value.outcome_side)?;
267    anyhow::ensure!(
268        side == direction(order.book_side, order.outcome_side)?,
269        "fill and order direction mismatch"
270    );
271    complementary(value.yes_price_dollars, value.no_price_dollars)?;
272    let qty = size(value.count_fp, instrument.size_precision)?;
273    let px = price(value.yes_price_dollars, instrument.price_precision)?;
274    anyhow::ensure!(
275        value.count_fp.0 <= order.fill_count_fp.0,
276        "fill exceeds reported cumulative count"
277    );
278    anyhow::ensure!(value.fee_cost.0 >= Decimal::ZERO, "negative fill fee");
279    let commission = Money::from_decimal_exact(value.fee_cost.0, Currency::USD())?;
280    let ts_event = timestamp(&value.created_time)?;
281    let venue_order_id = VenueOrderId::new_checked(&value.order_id)?;
282    let trade_id = TradeId::new_checked(&value.fill_id)?;
283    let client_order_id = client_id(&order.client_order_id)?;
284
285    let liquidity = if value.is_taker {
286        LiquiditySide::Taker
287    } else {
288        LiquiditySide::Maker
289    };
290
291    let report = FillReport::new(
292        account_id,
293        instrument.id,
294        venue_order_id,
295        trade_id,
296        side,
297        qty,
298        px,
299        commission,
300        liquidity,
301        client_order_id,
302        None,
303        ts_event,
304        ts_init,
305        None,
306    );
307
308    Ok(report)
309}
310
311pub(super) fn position(
312    value: &MarketPosition,
313    instrument: &BinaryOption,
314    account_id: AccountId,
315    ts_init: UnixNanos,
316) -> anyhow::Result<PositionStatusReport> {
317    anyhow::ensure!(
318        parse_instrument_id(&value.ticker)? == instrument.id,
319        "position instrument mismatch"
320    );
321    let signed = value.position_fp.0;
322
323    let side = if signed > Decimal::ZERO {
324        PositionSide::Long
325    } else if signed < Decimal::ZERO {
326        PositionSide::Short
327    } else {
328        PositionSide::Flat
329    };
330
331    let magnitude = if signed < Decimal::ZERO {
332        signed.abs()
333    } else {
334        signed
335    };
336
337    let qty = quantity(FixedPoint(magnitude), instrument.size_precision)?;
338    let ts_last = timestamp(&Field::Value(value.last_updated_ts))?;
339
340    let report = PositionStatusReport::new(
341        account_id,
342        instrument.id,
343        side,
344        qty,
345        ts_last,
346        ts_init,
347        None,
348        None,
349        None,
350    );
351
352    Ok(report)
353}
354
355pub(super) fn quantity(value: FixedPoint, precision: u8) -> anyhow::Result<Quantity> {
356    anyhow::ensure!(
357        value.0 >= Decimal::ZERO,
358        "negative order or position magnitude"
359    );
360
361    if value.0.is_zero() {
362        return Ok(Quantity::zero(precision));
363    }
364
365    size(value, precision)
366}
367
368pub(super) fn direction(book: BookSide, outcome: OutcomeSide) -> anyhow::Result<OrderSide> {
369    match (book, outcome) {
370        (BookSide::Bid, OutcomeSide::Yes) => Ok(OrderSide::Buy),
371        (BookSide::Ask, OutcomeSide::No) => Ok(OrderSide::Sell),
372        _ => anyhow::bail!("inconsistent canonical execution direction"),
373    }
374}
375
376pub(super) fn complementary(yes: FixedPoint, no: FixedPoint) -> anyhow::Result<()> {
377    anyhow::ensure!(
378        yes.0.checked_add(no.0) == Some(Decimal::ONE),
379        "inconsistent complementary execution prices"
380    );
381    Ok(())
382}
383
384fn client_id(value: &str) -> anyhow::Result<Option<ClientOrderId>> {
385    if value.is_empty() {
386        Ok(None)
387    } else {
388        Ok(Some(ClientOrderId::new_checked(value)?))
389    }
390}
391
392#[cfg(test)]
393mod tests {
394    use nautilus_core::UUID4;
395    use nautilus_model::{
396        events::{OrderAccepted, OrderCanceled, OrderEventAny, OrderRejected, OrderSubmitted},
397        orders::builder::OrderTestBuilder,
398        types::Price,
399    };
400    use rstest::rstest;
401    use serde_json::Value;
402
403    use super::*;
404    use crate::http::{
405        models::{Event, Market},
406        parse::parse_instrument,
407    };
408
409    #[rstest]
410    #[case("0.00", PositionSide::Flat)]
411    #[case("7.25", PositionSide::Long)]
412    #[case("-3.50", PositionSide::Short)]
413    fn position_preserves_sign_flat_and_exact_fields(
414        #[case] signed: &str,
415        #[case] side: PositionSide,
416    ) {
417        let instrument = instrument();
418        let mut value: MarketPosition =
419            serde_json::from_value(fixture("positions")["market_positions"][0].clone()).unwrap();
420        value.ticker = instrument.id.symbol.to_string();
421        value.position_fp = FixedPoint(signed.parse().unwrap());
422        let report = position(
423            &value,
424            &instrument,
425            AccountId::from("KALSHI-007"),
426            UnixNanos::from(543),
427        )
428        .unwrap();
429        assert_eq!(report.account_id, AccountId::from("KALSHI-007"));
430        assert_eq!(report.instrument_id, instrument.id);
431        assert_eq!(report.position_side, side);
432        assert_eq!(
433            report.quantity.as_decimal(),
434            signed.parse::<Decimal>().unwrap().abs()
435        );
436        assert_eq!(
437            report.signed_decimal_qty,
438            signed.parse::<Decimal>().unwrap()
439        );
440        assert_eq!(
441            report.ts_last,
442            try_datetime_to_unix_nanos(value.last_updated_ts).unwrap()
443        );
444        assert_eq!(report.ts_init, UnixNanos::from(543));
445        assert_eq!(report.venue_position_id, None);
446        assert_eq!(report.avg_px_open, None);
447        assert_eq!(report.avg_px_open_reconciliation, Default::default());
448        assert_eq!(report.avg_px_open_precision, None);
449    }
450
451    #[rstest]
452    #[case(BookSide::Bid, OutcomeSide::Yes, OrderSide::Buy, true)]
453    #[case(BookSide::Ask, OutcomeSide::No, OrderSide::Sell, false)]
454    fn fill_preserves_every_report_field_and_authoritative_fee(
455        #[case] book: BookSide,
456        #[case] outcome: OutcomeSide,
457        #[case] side: OrderSide,
458        #[case] taker: bool,
459    ) {
460        let instrument = instrument();
461        let mut raw: Fill = serde_json::from_value(fixture("fills")["fills"][0].clone()).unwrap();
462        let mut context = venue_order(&instrument);
463        raw.ticker = instrument.id.symbol.to_string();
464        raw.market_ticker = raw.ticker.clone();
465        raw.book_side = book;
466        raw.outcome_side = outcome;
467        raw.is_taker = taker;
468        context.book_side = book;
469        context.outcome_side = outcome;
470        context.fill_count_fp = raw.count_fp;
471        let report = fill(
472            &raw,
473            &instrument,
474            AccountId::from("KALSHI-007"),
475            &context,
476            UnixNanos::from(543),
477        )
478        .unwrap();
479        assert_eq!(report.account_id, AccountId::from("KALSHI-007"));
480        assert_eq!(report.instrument_id, instrument.id);
481        assert_eq!(report.venue_order_id, VenueOrderId::from("order-a"));
482        assert_eq!(report.trade_id, TradeId::from("fill-a"));
483        assert_eq!(report.order_side, side);
484        assert_eq!(
485            report.last_qty.as_decimal(),
486            "2.75".parse::<Decimal>().unwrap()
487        );
488        assert_eq!(
489            report.last_px.as_decimal(),
490            "0.123456".parse::<Decimal>().unwrap()
491        );
492        assert_eq!(
493            report.commission,
494            Money::from_decimal_exact("0.000001".parse().unwrap(), Currency::USD()).unwrap()
495        );
496        assert_eq!(
497            report.liquidity_side,
498            if taker {
499                LiquiditySide::Taker
500            } else {
501                LiquiditySide::Maker
502            }
503        );
504        assert_eq!(report.avg_px, None);
505        assert_eq!(
506            report.client_order_id,
507            Some(ClientOrderId::from("client-a"))
508        );
509        assert_eq!(report.venue_position_id, None);
510        assert_eq!(report.ts_event, timestamp(&raw.created_time).unwrap());
511        assert_eq!(report.ts_init, UnixNanos::from(543));
512    }
513
514    #[rstest]
515    #[case("direction")]
516    #[case("price")]
517    #[case("fee")]
518    #[case("commission_bounds")]
519    #[case("qty")]
520    #[case("timestamp")]
521    #[case("identity")]
522    fn invalid_fill_economics_or_identity_fail(#[case] mode: &str) {
523        let instrument = instrument();
524        let mut value: Fill = serde_json::from_value(fixture("fills")["fills"][0].clone()).unwrap();
525        value.ticker = instrument.id.symbol.to_string();
526        value.market_ticker = value.ticker.clone();
527        value.outcome_side = OutcomeSide::Yes;
528        let mut context = venue_order(&instrument);
529        context.book_side = BookSide::Bid;
530        context.outcome_side = OutcomeSide::Yes;
531        context.fill_count_fp = value.count_fp;
532        match mode {
533            "direction" => value.outcome_side = OutcomeSide::No,
534            "price" => value.no_price_dollars = FixedPoint("0.10".parse().unwrap()),
535            "fee" => value.fee_cost = FixedPoint("-0.000001".parse().unwrap()),
536            "commission_bounds" => value.fee_cost = FixedPoint(Decimal::MAX),
537            "qty" => value.count_fp = FixedPoint("2.751".parse().unwrap()),
538            "timestamp" => value.created_time = Field::Missing,
539            "identity" => value.order_id = "wrong-order".into(),
540            _ => unreachable!(),
541        }
542
543        assert!(
544            fill(
545                &value,
546                &instrument,
547                AccountId::from("KALSHI-007"),
548                &context,
549                UnixNanos::from(543)
550            )
551            .is_err()
552        );
553    }
554
555    #[rstest]
556    #[case("0.0001")]
557    #[case("-2.751")]
558    fn unsupported_position_precision_fails(#[case] signed: &str) {
559        let instrument = instrument();
560        let mut value: MarketPosition =
561            serde_json::from_value(fixture("positions")["market_positions"][0].clone()).unwrap();
562        value.ticker = instrument.id.symbol.to_string();
563        value.position_fp = FixedPoint(signed.parse().unwrap());
564        assert!(
565            position(
566                &value,
567                &instrument,
568                AccountId::from("KALSHI-007"),
569                UnixNanos::from(543)
570            )
571            .is_err()
572        );
573    }
574
575    #[rstest]
576    fn resting_order_uses_exact_totals_and_proven_command_metadata() {
577        let instrument = instrument();
578        let value = venue_order(&instrument);
579        let cached = cached_order(&instrument);
580        let report = order(
581            &value,
582            &instrument,
583            AccountId::from("KALSHI-007"),
584            Some(&cached),
585            UnixNanos::from(543),
586        )
587        .unwrap()
588        .unwrap();
589        assert_eq!(report.account_id, AccountId::from("KALSHI-007"));
590        assert_eq!(report.instrument_id, instrument.id);
591        assert_eq!(
592            report.client_order_id,
593            Some(ClientOrderId::from("client-a"))
594        );
595        assert_eq!(report.venue_order_id, VenueOrderId::from("order-a"));
596        assert_eq!(report.order_side, Some(OrderSide::Sell));
597        assert_eq!(report.order_type, OrderType::Limit);
598        assert_eq!(report.time_in_force, TimeInForce::Gtc);
599        assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
600        assert_eq!(
601            report.quantity.as_decimal(),
602            "5.75".parse::<Decimal>().unwrap()
603        );
604        assert_eq!(
605            report.filled_qty.as_decimal(),
606            "2.25".parse::<Decimal>().unwrap()
607        );
608        assert_eq!(
609            report.price.unwrap().as_decimal(),
610            "0.123401".parse::<Decimal>().unwrap()
611        );
612        assert_eq!(report.ts_accepted, timestamp(&value.created_time).unwrap());
613        assert_eq!(report.ts_last, timestamp(&value.last_update_time).unwrap());
614        assert_eq!(report.ts_init, UnixNanos::from(543));
615        assert!(report.post_only);
616        assert!(!report.reduce_only);
617        assert_eq!(report.expire_time, None);
618        assert_eq!(report.avg_px, None);
619    }
620
621    #[rstest]
622    #[case(false, TimeInForce::Gtc)]
623    #[case(true, TimeInForce::Gtd)]
624    fn external_metadata_uses_recovery_defaults(#[case] expires: bool, #[case] tif: TimeInForce) {
625        let instrument = instrument();
626        let mut value = venue_order(&instrument);
627        let expiry: jiff::Timestamp = "2026-10-17T12:34:56.123456789Z".parse().unwrap();
628        value.expiration_time = if expires {
629            Field::Value(expiry)
630        } else {
631            Field::Null
632        };
633
634        let report = order(
635            &value,
636            &instrument,
637            AccountId::from("KALSHI-007"),
638            None,
639            UnixNanos::from(543),
640        )
641        .unwrap()
642        .unwrap();
643        let mut cached = cached_order(&instrument);
644
645        // Compare the full report against the existing converter with equivalent known instructions
646        if expires {
647            cached = OrderTestBuilder::new(OrderType::Limit)
648                .instrument_id(instrument.id)
649                .client_order_id(ClientOrderId::from("client-a"))
650                .side(OrderSide::Sell)
651                .quantity(Quantity::from("5.75"))
652                .price(Price::from("0.123401"))
653                .time_in_force(TimeInForce::Gtd)
654                .expire_time(try_datetime_to_unix_nanos(expiry).unwrap())
655                .build();
656        }
657
658        let mut expected = order(
659            &value,
660            &instrument,
661            AccountId::from("KALSHI-007"),
662            Some(&cached),
663            UnixNanos::from(543),
664        )
665        .unwrap()
666        .unwrap();
667        expected.report_id = report.report_id;
668        expected.post_only = false;
669        assert_eq!(report, expected);
670        assert_eq!(report.time_in_force, tif);
671        assert!(!report.post_only);
672        assert!(!report.reduce_only);
673    }
674
675    #[rstest]
676    fn external_canceled_quantity_is_not_inferred_from_original_count() {
677        let instrument = instrument();
678        let mut value = venue_order(&instrument);
679        value.status = VenueOrderStatus::Canceled;
680        value.remaining_count_fp = FixedPoint(Decimal::ZERO);
681        assert_eq!(
682            order(
683                &value,
684                &instrument,
685                AccountId::from("KALSHI-007"),
686                None,
687                UnixNanos::from(543)
688            )
689            .unwrap(),
690            None
691        );
692    }
693
694    #[rstest]
695    fn canceled_original_count_does_not_establish_final_total() {
696        let instrument = instrument();
697        let mut value = venue_order(&instrument);
698        value.status = VenueOrderStatus::Canceled;
699        value.remaining_count_fp = FixedPoint(Decimal::ZERO);
700        let cached = cached_order(&instrument);
701        assert_eq!(
702            order(
703                &value,
704                &instrument,
705                AccountId::from("KALSHI-007"),
706                Some(&cached),
707                UnixNanos::from(543)
708            )
709            .unwrap(),
710            None
711        );
712    }
713
714    #[rstest]
715    fn mismatched_cached_identity_is_an_error() {
716        let instrument = instrument();
717        let mut value = venue_order(&instrument);
718        value.client_order_id = "another-client".into();
719        assert!(
720            order(
721                &value,
722                &instrument,
723                AccountId::from("KALSHI-007"),
724                Some(&cached_order(&instrument)),
725                UnixNanos::from(543)
726            )
727            .is_err()
728        );
729    }
730
731    #[rstest]
732    fn executed_order_preserves_its_final_filled_total() {
733        let instrument = instrument();
734        let mut value = venue_order(&instrument);
735        value.status = VenueOrderStatus::Executed;
736        value.remaining_count_fp = FixedPoint(Decimal::ZERO);
737        let report = order(
738            &value,
739            &instrument,
740            AccountId::from("KALSHI-007"),
741            Some(&cached_order(&instrument)),
742            UnixNanos::from(543),
743        )
744        .unwrap()
745        .unwrap();
746        assert_eq!(report.order_status, OrderStatus::Filled);
747        assert_eq!(
748            report.quantity.as_decimal(),
749            "2.25".parse::<Decimal>().unwrap()
750        );
751        assert_eq!(report.filled_qty, report.quantity);
752    }
753
754    #[rstest]
755    fn unknown_order_status_is_an_error() {
756        let instrument = instrument();
757        let mut value = venue_order(&instrument);
758        value.status = VenueOrderStatus::Unknown;
759        assert!(
760            order(
761                &value,
762                &instrument,
763                AccountId::from("KALSHI-007"),
764                Some(&cached_order(&instrument)),
765                UnixNanos::from(543)
766            )
767            .unwrap_err()
768            .to_string()
769            .contains("unknown Kalshi order status")
770        );
771    }
772
773    #[rstest]
774    fn gtd_order_preserves_authoritative_expiration() {
775        let instrument = instrument();
776        let mut value = venue_order(&instrument);
777        let expiry: jiff::Timestamp = "2026-10-17T12:34:56.123456789Z".parse().unwrap();
778        value.expiration_time = Field::Value(expiry);
779        let expiry = try_datetime_to_unix_nanos(expiry).unwrap();
780        let cached = OrderTestBuilder::new(OrderType::Limit)
781            .instrument_id(instrument.id)
782            .client_order_id(ClientOrderId::from("client-a"))
783            .side(OrderSide::Sell)
784            .quantity(Quantity::from_decimal_dp("5.75".parse().unwrap(), 2).unwrap())
785            .price(Price::from_decimal_dp("0.123401".parse().unwrap(), 6).unwrap())
786            .time_in_force(TimeInForce::Gtd)
787            .expire_time(expiry)
788            .build();
789        let report = order(
790            &value,
791            &instrument,
792            AccountId::from("KALSHI-007"),
793            Some(&cached),
794            UnixNanos::from(543),
795        )
796        .unwrap()
797        .unwrap();
798        assert_eq!(report.time_in_force, TimeInForce::Gtd);
799        assert_eq!(report.expire_time, Some(expiry));
800    }
801
802    #[rstest]
803    fn canceled_order_uses_proven_total_instead_of_initial_count() {
804        let instrument = instrument();
805        let mut value = venue_order(&instrument);
806        value.status = VenueOrderStatus::Canceled;
807        value.fill_count_fp = FixedPoint(Decimal::ZERO);
808        value.remaining_count_fp = FixedPoint(Decimal::ZERO);
809        value.initial_count_fp = FixedPoint("10.00".parse().unwrap());
810        let mut cached = cached_order(&instrument);
811        let account = AccountId::from("KALSHI-007");
812        let venue = VenueOrderId::from("order-a");
813        cached
814            .apply(OrderEventAny::Accepted(OrderAccepted::new(
815                cached.trader_id(),
816                cached.strategy_id(),
817                instrument.id,
818                cached.client_order_id(),
819                venue,
820                account,
821                UUID4::new(),
822                timestamp(&value.created_time).unwrap(),
823                UnixNanos::from(123),
824                false,
825            )))
826            .unwrap();
827        cached
828            .apply(OrderEventAny::Canceled(OrderCanceled::new(
829                cached.trader_id(),
830                cached.strategy_id(),
831                instrument.id,
832                cached.client_order_id(),
833                UUID4::new(),
834                timestamp(&value.last_update_time).unwrap(),
835                UnixNanos::from(234),
836                false,
837                Some(venue),
838                Some(account),
839                None,
840            )))
841            .unwrap();
842        let report = order(
843            &value,
844            &instrument,
845            account,
846            Some(&cached),
847            UnixNanos::from(543),
848        )
849        .unwrap()
850        .unwrap();
851        assert_eq!(report.order_status, OrderStatus::Canceled);
852        assert_eq!(
853            report.quantity.as_decimal(),
854            "5.75".parse::<Decimal>().unwrap()
855        );
856        assert_eq!(report.filled_qty, Quantity::zero(2));
857    }
858
859    #[rstest]
860    fn post_only_rejection_relaxes_timestamp_only_for_aggregate() {
861        let instrument = instrument();
862        let mut value = venue_order(&instrument);
863        value.status = VenueOrderStatus::Canceled;
864        value.fill_count_fp = FixedPoint(Decimal::ZERO);
865        value.remaining_count_fp = FixedPoint(Decimal::ZERO);
866        let account = AccountId::from("KALSHI-007");
867        let submitted_at = timestamp(&value.created_time).unwrap();
868        let rejected_at = UnixNanos::from(timestamp(&value.last_update_time).unwrap().as_u64() + 1);
869        let mut cached = cached_order(&instrument);
870        cached
871            .apply(OrderEventAny::Submitted(OrderSubmitted::new(
872                cached.trader_id(),
873                cached.strategy_id(),
874                instrument.id,
875                cached.client_order_id(),
876                account,
877                UUID4::new(),
878                submitted_at,
879                submitted_at,
880            )))
881            .unwrap();
882        cached
883            .apply(OrderEventAny::Rejected(OrderRejected::new(
884                cached.trader_id(),
885                cached.strategy_id(),
886                instrument.id,
887                cached.client_order_id(),
888                account,
889                "Post-only order would cross".into(),
890                UUID4::new(),
891                rejected_at,
892                rejected_at,
893                false,
894                true,
895            )))
896            .unwrap();
897
898        let ordinary = order(
899            &value,
900            &instrument,
901            account,
902            Some(&cached),
903            UnixNanos::from(543),
904        )
905        .unwrap();
906        let aggregate =
907            order_aggregate(&value, &instrument, account, &cached, UnixNanos::from(543))
908                .unwrap()
909                .unwrap();
910
911        assert_eq!(ordinary, None);
912        assert_eq!(aggregate.order_status, OrderStatus::Rejected);
913        assert_eq!(aggregate.quantity, Quantity::from("5.75"));
914        assert_eq!(aggregate.filled_qty, Quantity::zero(2));
915        assert_eq!(
916            aggregate.ts_last,
917            timestamp(&value.last_update_time).unwrap()
918        );
919        assert_ne!(aggregate.ts_last, rejected_at);
920        assert!(aggregate.post_only);
921    }
922
923    #[rstest]
924    fn missing_position_update_time_is_an_error() {
925        let instrument = instrument();
926        let mut value: MarketPosition =
927            serde_json::from_value(fixture("positions")["market_positions"][0].clone()).unwrap();
928        value.ticker = instrument.id.symbol.to_string();
929        value.last_updated_ts = jiff::Timestamp::UNIX_EPOCH;
930        assert!(
931            position(
932                &value,
933                &instrument,
934                AccountId::from("KALSHI-007"),
935                UnixNanos::from(543)
936            )
937            .unwrap_err()
938            .to_string()
939            .contains("invalid execution timestamp")
940        );
941    }
942
943    fn fixture(name: &str) -> Value {
944        let f: Value =
945            serde_json::from_str(include_str!("../../test_data/rest_responses.json")).unwrap();
946        f[name].clone()
947    }
948
949    fn instrument() -> BinaryOption {
950        let f: Value =
951            serde_json::from_str(include_str!("../../test_data/instruments.json")).unwrap();
952        let market: Market =
953            serde_json::from_value(f["definitions"]["live"]["market"].clone()).unwrap();
954        let event: Event =
955            serde_json::from_value(f["definitions"]["live"]["event"].clone()).unwrap();
956        parse_instrument(&market, &event, UnixNanos::from(1)).unwrap()
957    }
958
959    fn venue_order(instrument: &BinaryOption) -> VenueOrder {
960        let mut value: VenueOrder =
961            serde_json::from_value(fixture("order")["order"].clone()).unwrap();
962        value.ticker = instrument.id.symbol.to_string();
963        value.outcome_side = OutcomeSide::No;
964        value
965    }
966
967    fn cached_order(instrument: &BinaryOption) -> OrderAny {
968        OrderTestBuilder::new(OrderType::Limit)
969            .instrument_id(instrument.id)
970            .client_order_id(ClientOrderId::from("client-a"))
971            .side(OrderSide::Sell)
972            .quantity(Quantity::from_decimal_dp("5.75".parse().unwrap(), 2).unwrap())
973            .price(Price::from_decimal_dp("0.123401".parse().unwrap(), 6).unwrap())
974            .time_in_force(TimeInForce::Gtc)
975            .post_only(true)
976            .build()
977    }
978}