1use 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
39pub 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
244pub 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 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}