1use std::{
19 collections::{HashMap, HashSet},
20 future::Future,
21 sync::Arc,
22 time::{Duration, Instant},
23};
24
25use anyhow::Context;
26use async_trait::async_trait;
27use indexmap::IndexMap;
28use jiff::Timestamp;
29use nautilus_common::{
30 cache::{Cache, InstrumentLookupError},
31 clients::ExecutionClient,
32 live::runner::get_exec_event_sender,
33 messages::execution::{
34 BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
35 GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
36 ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
37 },
38};
39use nautilus_core::{
40 AtomicMap, DurationNanos, Params, UUID4, UnixNanos,
41 time::{AtomicTime, get_atomic_clock_realtime},
42};
43use nautilus_live::{
44 ExecutionClientCore, ExecutionEventEmitter, SocketControl, execution::failure::CommandFailure,
45 task::TaskGroup,
46};
47use nautilus_model::{
48 accounts::AccountAny,
49 enums::{AccountType, OmsType, OrderSide, OrderStatus, OrderType},
50 events::OrderDeniedReason,
51 identifiers::{
52 AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, TradeId, Venue, VenueOrderId,
53 },
54 instruments::{Instrument, InstrumentAny},
55 orders::{Order, OrderAny},
56 reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
57 types::{AccountBalance, MarginBalance, Quantity},
58};
59use rust_decimal::Decimal;
60use tokio_util::sync::CancellationToken;
61
62use super::{
63 absent_unless_unread, cached_order_for_status_command, command_failure_from_cancel_error,
64 command_failure_from_futures_batch_error, command_failure_from_futures_batch_item,
65 command_failure_from_modify_error, command_failure_from_submit_error, earliest_venue_time,
66 status_command_label,
67};
68use crate::{
69 common::{
70 consts::{KRAKEN_FUTURES_MAX_CLIENT_ORDER_ID_LEN, KRAKEN_VENUE},
71 credential::KrakenCredential,
72 enums::{KrakenApiResult, KrakenProductType, KrakenSendStatus, product_type_from_symbol},
73 parse::truncate_cl_ord_id,
74 },
75 config::KrakenExecutionClientConfig,
76 http::{
77 KrakenFuturesHttpClient, KrakenHttpError,
78 futures::{
79 client::{KRAKEN_FUTURES_DEFAULT_RATE_LIMIT_PER_SECOND, order_identifier, supersedes},
80 models::FuturesBatchCancelStatus,
81 query::KrakenFuturesBatchCancelItem,
82 },
83 },
84 websocket::{
85 dispatch::{self, OrderIdentity, WsDispatchState},
86 futures::{client::KrakenFuturesWebSocketClient, messages::KrakenFuturesWsMessage},
87 },
88};
89
90const FUTURES_BATCH_CANCEL_LIMIT: usize = 50;
91
92const FUTURES_ORDERS_STATUS_LIMIT: usize = 50;
94
95const ORDERS_STATUS_CLOCK_SKEW: DurationNanos = DurationNanos::from_secs(5);
99
100#[allow(dead_code)]
105#[derive(Debug)]
106pub struct KrakenFuturesExecutionClient {
107 core: ExecutionClientCore,
108 clock: &'static AtomicTime,
109 config: KrakenExecutionClientConfig,
110 emitter: ExecutionEventEmitter,
111 http: KrakenFuturesHttpClient,
112 ws: KrakenFuturesWebSocketClient,
113 cancellation_token: CancellationToken,
114 session_tasks: TaskGroup,
115 pending_tasks: TaskGroup,
116 instruments: Arc<AtomicMap<InstrumentId, InstrumentAny>>,
117 truncated_id_map: Arc<AtomicMap<String, ClientOrderId>>,
118 order_instrument_map: Arc<AtomicMap<String, InstrumentId>>,
119 venue_client_map: Arc<AtomicMap<String, ClientOrderId>>,
120 venue_order_qty: Arc<AtomicMap<String, Quantity>>,
121 ws_dispatch_state: Arc<WsDispatchState>,
122}
123
124impl KrakenFuturesExecutionClient {
125 pub fn new(
131 core: ExecutionClientCore,
132 config: KrakenExecutionClientConfig,
133 ) -> anyhow::Result<Self> {
134 config.validate()?;
135
136 let clock = get_atomic_clock_realtime();
137 let emitter = ExecutionEventEmitter::new(
138 clock,
139 core.trader_id,
140 core.account_id,
141 AccountType::Margin,
142 None,
143 );
144
145 let session_tasks = TaskGroup::new();
146 let cancellation_token = session_tasks.cancellation_token();
147 let pending_tasks = TaskGroup::new();
148 let api_key = config.api_key.expose_secret().to_owned();
149 let api_secret = config.api_secret.expose_secret().to_owned();
150 let proxy_url = config
151 .proxy_url
152 .as_ref()
153 .map(|value| value.expose_secret().to_owned());
154
155 let http = KrakenFuturesHttpClient::with_credentials(
156 api_key.clone(),
157 api_secret.clone(),
158 config.environment,
159 config.base_url.clone(),
160 config.timeout_secs,
161 Some(config.max_retries),
162 None,
163 None,
164 proxy_url.clone(),
165 config
166 .max_requests_per_second
167 .unwrap_or(KRAKEN_FUTURES_DEFAULT_RATE_LIMIT_PER_SECOND),
168 )?;
169
170 let credential = KrakenCredential::new(api_key, api_secret);
171 let ws = KrakenFuturesWebSocketClient::with_credentials(
172 config.ws_url(),
173 config.heartbeat_interval_secs,
174 Some(credential),
175 config.auth_timeout_secs,
176 config.transport_backend,
177 proxy_url,
178 )
179 .with_socket_control(SocketControl::new(
180 core.client_id,
181 Some(*KRAKEN_VENUE),
182 "kraken-futures-user-streams",
183 ));
184
185 Ok(Self {
186 core,
187 clock,
188 config,
189 emitter,
190 http,
191 ws,
192 cancellation_token,
193 session_tasks,
194 pending_tasks,
195 instruments: Arc::new(AtomicMap::new()),
196 truncated_id_map: Arc::new(AtomicMap::new()),
197 order_instrument_map: Arc::new(AtomicMap::new()),
198 venue_client_map: Arc::new(AtomicMap::new()),
199 venue_order_qty: Arc::new(AtomicMap::new()),
200 ws_dispatch_state: Arc::new(WsDispatchState::new()),
201 })
202 }
203
204 fn register_order_identity(&self, order: &OrderAny) {
205 self.ws_dispatch_state.register_identity(
206 order.client_order_id(),
207 OrderIdentity {
208 strategy_id: order.strategy_id(),
209 instrument_id: order.instrument_id(),
210 order_side: order.order_side(),
211 order_type: order.order_type(),
212 quantity: order.quantity(),
213 },
214 );
215 }
216
217 #[must_use]
219 pub fn clock(&self) -> &'static AtomicTime {
220 self.clock
221 }
222
223 #[must_use]
225 pub fn emitter(&self) -> &ExecutionEventEmitter {
226 &self.emitter
227 }
228
229 fn spawn_task<F>(&self, description: &'static str, fut: F)
230 where
231 F: Future<Output = anyhow::Result<()>> + Send + 'static,
232 {
233 let future = async move {
234 if let Err(e) = fut.await {
235 log::warn!("{description} failed: {e:?}");
236 }
237 };
238
239 if let Err(e) = self.pending_tasks.spawn(future) {
240 log::warn!("Skipping Kraken Futures {description} after shutdown began: {e}");
241 }
242 }
243
244 async fn finish_tasks(&self) -> anyhow::Result<()> {
245 let (session_result, pending_result) = tokio::join!(
246 self.session_tasks
247 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2)),
248 self.pending_tasks
249 .finish_shutdown(Duration::from_secs(2), Duration::from_secs(2)),
250 );
251 session_result.context("failed to finish Kraken Futures execution session tasks")?;
252 pending_result.context("failed to finish Kraken Futures execution command tasks")?;
253 Ok(())
254 }
255
256 async fn prepare_task_groups(&mut self) -> anyhow::Result<()> {
257 if !self.session_tasks.is_open() || !self.pending_tasks.is_open() {
258 self.session_tasks.begin_shutdown();
259 self.pending_tasks.begin_shutdown();
260 self.finish_tasks().await?;
261 self.session_tasks
262 .start_generation()
263 .context("failed to start Kraken Futures execution session task generation")?;
264 self.pending_tasks
265 .start_generation()
266 .context("failed to start Kraken Futures execution command task generation")?;
267 self.cancellation_token = self.session_tasks.cancellation_token();
268 }
269 Ok(())
270 }
271
272 async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
273 self.http.cancel_all_requests();
274 self.pending_tasks.begin_shutdown();
275 let ws_result = self.ws.close().await;
276 self.session_tasks.begin_shutdown();
277 let tasks_result = self.finish_tasks().await;
278 self.core.set_disconnected();
279 tasks_result?;
280 Ok(ws_result?)
281 }
282
283 fn submit_single_order(&self, order: &OrderAny, task_name: &'static str) {
284 if order.is_closed() {
285 log::warn!(
286 "Cannot submit closed order: client_order_id={}",
287 order.client_order_id()
288 );
289 return;
290 }
291
292 if let Err(reason) = validate_order(order) {
293 self.emitter.emit_order_denied(order, &reason.to_string());
294 return;
295 }
296
297 let account_id = self.core.account_id;
298 let client_order_id = order.client_order_id();
299 let strategy_id = order.strategy_id();
300 let instrument_id = order.instrument_id();
301 let order_side = order.order_side();
302 let order_type = order.order_type();
303 let quantity = order.quantity();
304 let time_in_force = order.time_in_force();
305 let price = order.price();
306 let trigger_price = order.trigger_price();
307 let trigger_type = order.trigger_type();
308 let is_reduce_only = order.is_reduce_only();
309 let is_post_only = order.is_post_only();
310
311 log::debug!("OrderSubmitted: client_order_id={client_order_id}");
312 self.register_order_identity(order);
313 self.emitter.emit_order_submitted(order);
314
315 let http = self.http.clone();
316 let emitter = self.emitter.clone();
317 let clock = self.clock;
318 let dispatch_state = self.ws_dispatch_state.clone();
319
320 self.spawn_task(task_name, async move {
321 let result = http
322 .submit_order(
323 account_id,
324 instrument_id,
325 client_order_id,
326 order_side,
327 order_type,
328 quantity,
329 time_in_force,
330 price,
331 trigger_price,
332 trigger_type,
333 is_reduce_only,
334 is_post_only,
335 )
336 .await;
337
338 match result {
339 Ok(_) => {}
340 Err(e) => match command_failure_from_submit_error(&e) {
341 CommandFailure::Ambiguous(reason) => {
342 log::warn!(
343 "{task_name} outcome is ambiguous for client_order_id={client_order_id}: {reason}"
344 );
345 }
346 CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason) => {
347 let ts_event = clock.get_time_ns();
348 let error_msg = format!("{task_name} error: {reason}");
349 let due_post_only = error_msg.contains("POST_ONLY_REJECTED");
350 dispatch_state.cleanup_terminal(&client_order_id);
351 emitter.emit_order_rejected_event(
352 strategy_id,
353 instrument_id,
354 client_order_id,
355 &error_msg,
356 ts_event,
357 due_post_only,
358 );
359 }
360 },
361 }
362 Ok(())
363 });
364 }
365
366 fn cancel_single_order(&self, cmd: &CancelOrder) {
367 let account_id = self.core.account_id;
368 let command_id = cmd.command_id;
369 let client_order_id = cmd.client_order_id;
370 let venue_order_id = cmd.venue_order_id;
371 let strategy_id = cmd.strategy_id;
372 let instrument_id = cmd.instrument_id;
373
374 log::debug!(
375 "Canceling order: venue_order_id={venue_order_id:?}, client_order_id={client_order_id}"
376 );
377
378 let http = self.http.clone();
379 let emitter = self.emitter.clone();
380 let clock = self.clock;
381
382 self.spawn_task("cancel_order", async move {
383 if let Err(failure) = cancel_order_for_futures(
384 &http,
385 account_id,
386 instrument_id,
387 Some(client_order_id),
388 venue_order_id,
389 )
390 .await
391 {
392 handle_cancel_failure(
393 &emitter,
394 clock,
395 strategy_id,
396 instrument_id,
397 client_order_id,
398 venue_order_id,
399 failure,
400 command_id,
401 );
402 }
403 Ok(())
404 });
405 }
406
407 fn spawn_message_handler(&mut self) -> anyhow::Result<()> {
408 let mut rx = self
409 .ws
410 .take_output_rx()
411 .context("Failed to take futures WebSocket output receiver")?;
412 let emitter = self.emitter.clone();
413 let instruments = self.instruments.clone();
414 let truncated_id_map = self.truncated_id_map.clone();
415 let order_instrument_map = self.order_instrument_map.clone();
416 let venue_client_map = self.venue_client_map.clone();
417 let venue_order_qty = self.venue_order_qty.clone();
418 let dispatch_state = self.ws_dispatch_state.clone();
419 let account_id = self.core.account_id;
420 let clock = self.clock;
421 let cancellation_token = self.cancellation_token.clone();
422
423 let future = async move {
424 loop {
425 tokio::select! {
426 () = cancellation_token.cancelled() => {
427 log::debug!("Futures execution message handler cancelled");
428 break;
429 }
430 msg = rx.recv() => {
431 match msg {
432 Some(ws_msg) => {
433 Self::handle_ws_message(
434 ws_msg,
435 &emitter,
436 &dispatch_state,
437 &instruments,
438 &truncated_id_map,
439 &order_instrument_map,
440 &venue_client_map,
441 &venue_order_qty,
442 account_id,
443 clock,
444 );
445 }
446 None => {
447 log::debug!("Futures execution WebSocket stream ended");
448 break;
449 }
450 }
451 }
452 }
453 }
454 };
455
456 self.session_tasks
457 .spawn(future)
458 .context("failed to register Kraken Futures execution stream task")
459 }
460
461 #[expect(clippy::too_many_arguments)]
462 fn handle_ws_message(
463 msg: KrakenFuturesWsMessage,
464 emitter: &ExecutionEventEmitter,
465 dispatch_state: &Arc<WsDispatchState>,
466 instruments: &Arc<AtomicMap<InstrumentId, InstrumentAny>>,
467 truncated_id_map: &Arc<AtomicMap<String, ClientOrderId>>,
468 order_instrument_map: &Arc<AtomicMap<String, InstrumentId>>,
469 venue_client_map: &Arc<AtomicMap<String, ClientOrderId>>,
470 venue_order_qty: &Arc<AtomicMap<String, Quantity>>,
471 account_id: AccountId,
472 clock: &'static AtomicTime,
473 ) {
474 let ts_init = clock.get_time_ns();
475
476 match msg {
477 KrakenFuturesWsMessage::OpenOrdersDelta(delta) => {
478 dispatch::futures::open_orders_delta(
479 &delta,
480 dispatch_state,
481 emitter,
482 instruments,
483 truncated_id_map,
484 order_instrument_map,
485 venue_client_map,
486 venue_order_qty,
487 account_id,
488 ts_init,
489 );
490 }
491 KrakenFuturesWsMessage::OpenOrdersCancel(cancel) => {
492 dispatch::futures::open_orders_cancel(
493 &cancel,
494 dispatch_state,
495 emitter,
496 truncated_id_map,
497 order_instrument_map,
498 venue_client_map,
499 venue_order_qty,
500 account_id,
501 ts_init,
502 );
503 }
504 KrakenFuturesWsMessage::FillsDelta(fills_delta) => {
505 dispatch::futures::fills_delta(
506 &fills_delta,
507 dispatch_state,
508 emitter,
509 instruments,
510 truncated_id_map,
511 venue_client_map,
512 account_id,
513 ts_init,
514 );
515 }
516 KrakenFuturesWsMessage::Challenge(challenge) => {
517 log::debug!("Received challenge: length={}", challenge.len());
518 }
519 KrakenFuturesWsMessage::Reconnected => {
520 log::info!("Futures execution WebSocket reconnected");
521 }
522 KrakenFuturesWsMessage::Ticker(_)
523 | KrakenFuturesWsMessage::Trade(_)
524 | KrakenFuturesWsMessage::BookSnapshot(_)
525 | KrakenFuturesWsMessage::BookDelta(_) => {}
526 }
527 }
528
529 async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
530 let account_id = self.core.account_id;
531
532 if self.core.cache().account(&account_id).is_some() {
533 log::info!("Account {account_id} registered");
534 return Ok(());
535 }
536
537 let start = Instant::now();
538 let timeout = Duration::from_secs_f64(timeout_secs);
539 let interval = Duration::from_millis(10);
540
541 loop {
542 tokio::time::sleep(interval).await;
543
544 if self.core.cache().account(&account_id).is_some() {
545 log::info!("Account {account_id} registered");
546 return Ok(());
547 }
548
549 if start.elapsed() >= timeout {
550 anyhow::bail!(
551 "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
552 );
553 }
554 }
555 }
556
557 fn modify_single_order(&self, cmd: &ModifyOrder) {
558 let command_id = cmd.command_id;
559 let client_order_id = cmd.client_order_id;
560 let venue_order_id = cmd.venue_order_id;
561 let strategy_id = cmd.strategy_id;
562 let instrument_id = cmd.instrument_id;
563 let quantity = cmd.quantity;
564 let price = cmd.price;
565
566 log::debug!(
567 "Modifying order: venue_order_id={venue_order_id:?}, client_order_id={client_order_id}"
568 );
569
570 let http = self.http.clone();
571 let emitter = self.emitter.clone();
572 let clock = self.clock;
573
574 self.spawn_task("modify_order", async move {
575 match http
576 .modify_order(
577 instrument_id,
578 Some(client_order_id),
579 venue_order_id,
580 quantity,
581 price,
582 None,
583 )
584 .await
585 {
586 Ok(_) => {}
587 Err(e) => match command_failure_from_modify_error(&e) {
588 CommandFailure::Ambiguous(reason) => {
589 log::warn!(
590 "modify_order outcome is ambiguous for client_order_id={client_order_id}: {reason}"
591 );
592 }
593 CommandFailure::NotSent(reason) => {
594 let ts_event = clock.get_time_ns();
595 emitter.emit_order_modify_denied_event(
596 strategy_id,
597 instrument_id,
598 client_order_id,
599 venue_order_id,
600 &format!("modify-order error: {reason}"),
601 ts_event,
602 Some(command_id),
603 );
604 }
605 CommandFailure::VenueRejected(reason) => {
606 let ts_event = clock.get_time_ns();
607 emitter.emit_order_modify_rejected_event(
608 strategy_id,
609 instrument_id,
610 client_order_id,
611 venue_order_id,
612 &format!("modify-order error: {reason}"),
613 ts_event,
614 Some(command_id),
615 );
616 }
617 },
618 }
619 Ok(())
620 });
621 }
622}
623
624#[async_trait(?Send)]
625impl ExecutionClient for KrakenFuturesExecutionClient {
626 fn is_connected(&self) -> bool {
627 self.core.is_connected()
628 }
629
630 fn client_id(&self) -> ClientId {
631 self.core.client_id
632 }
633
634 fn account_id(&self) -> AccountId {
635 self.core.account_id
636 }
637
638 fn venue(&self) -> Venue {
639 *KRAKEN_VENUE
640 }
641
642 fn oms_type(&self) -> OmsType {
643 self.core.oms_type
644 }
645
646 fn get_account(&self) -> Option<AccountAny> {
647 self.core.cache().account_owned(&self.core.account_id)
648 }
649
650 fn generate_account_state(
651 &self,
652 balances: Vec<AccountBalance>,
653 margins: Vec<MarginBalance>,
654 reported: bool,
655 ts_event: UnixNanos,
656 info: Option<Params>,
657 ) -> anyhow::Result<()> {
658 self.emitter
659 .emit_account_state(balances, margins, reported, ts_event, info);
660 Ok(())
661 }
662
663 fn start(&mut self) -> anyhow::Result<()> {
664 if self.core.is_started() {
665 return Ok(());
666 }
667
668 self.emitter.set_sender(get_exec_event_sender());
669 self.core.set_started();
670
671 log::info!(
672 "Started: client_id={}, account_id={}, product_type=Futures, environment={:?}",
673 self.core.client_id,
674 self.core.account_id,
675 self.config.environment
676 );
677 Ok(())
678 }
679
680 fn stop(&mut self) -> anyhow::Result<()> {
681 if self.core.is_stopped() {
682 return Ok(());
683 }
684
685 self.http.cancel_all_requests();
686 self.session_tasks.begin_shutdown();
687 self.pending_tasks.begin_shutdown();
688 self.ws.begin_shutdown();
689 self.core.set_stopped();
690 self.core.set_disconnected();
691 log::info!("Stopped: client_id={}", self.core.client_id);
692 Ok(())
693 }
694
695 async fn connect(&mut self) -> anyhow::Result<()> {
696 if self.core.is_connected() && self.session_tasks.is_open() && self.pending_tasks.is_open()
697 {
698 return Ok(());
699 }
700
701 self.http.reset_cancellation_token();
702 self.prepare_task_groups().await?;
703
704 if !self.core.instruments_initialized() {
705 let instruments = self
706 .http
707 .request_instruments()
708 .await
709 .context("Failed to load Kraken futures instruments")?;
710 log::debug!("Loaded {} Futures instruments", instruments.len());
711 self.http.cache_instruments(&instruments);
712 self.core.set_instruments_initialized();
713 }
714
715 self.instruments.rcu(|m| {
716 for instrument in self.http.instruments_cache.load().values() {
717 m.insert(instrument.id(), instrument.clone());
718 }
719 });
720
721 let session_result = async {
722 self.ws
723 .connect()
724 .await
725 .context("Failed to connect futures WebSocket")?;
726 self.ws
727 .wait_until_active(10.0)
728 .await
729 .context("Futures WebSocket failed to become active")?;
730
731 self.ws
732 .authenticate()
733 .await
734 .context("Failed to authenticate futures WebSocket")?;
735
736 let account_state = self
737 .http
738 .request_account_state(self.core.account_id)
739 .await
740 .context("Failed to request Kraken futures account state")?;
741
742 if !account_state.balances.is_empty() {
743 log::debug!(
744 "Received account state with {} balance(s)",
745 account_state.balances.len()
746 );
747 }
748 self.emitter.send_account_state(account_state);
749 self.await_account_registered(30.0).await?;
750
751 self.spawn_message_handler()?;
752
753 self.ws
754 .subscribe_executions()
755 .await
756 .context("Failed to subscribe to executions")?;
757
758 log::debug!("Futures WebSocket authenticated and subscribed to executions");
759
760 Ok::<(), anyhow::Error>(())
761 }
762 .await;
763
764 if let Err(e) = session_result {
765 if let Err(teardown_error) = self.teardown_partial_connect().await {
766 return Err(e.context(format!(
767 "Kraken Futures execution startup teardown failed: {teardown_error}"
768 )));
769 }
770 return Err(e);
771 }
772
773 self.core.set_connected();
774 log::info!("Connected: client_id={}", self.core.client_id);
775 Ok(())
776 }
777
778 async fn disconnect(&mut self) -> anyhow::Result<()> {
779 self.teardown_partial_connect().await?;
780 log::info!("Disconnected: client_id={}", self.core.client_id);
781 Ok(())
782 }
783
784 async fn generate_order_status_report(
785 &self,
786 cmd: &GenerateOrderStatusReport,
787 ) -> anyhow::Result<Option<OrderStatusReport>> {
788 log::debug!(
789 "Generating order status report: venue_order_id={:?}, client_order_id={:?}",
790 cmd.venue_order_id,
791 cmd.client_order_id
792 );
793
794 let account_id = self.core.account_id;
795 let cached = cached_order_for_status_command(&self.core.cache(), cmd);
796 let queried = QueriedOrder::new(cmd, cached.as_ref());
797
798 let (mut reports, coverage) = self
801 .http
802 .request_order_status_reports_checked(account_id, cmd.instrument_id, None, None, false)
803 .await?;
804
805 reports.extend_from_slice(coverage.withheld());
808 name_reports_by_cached_order(&self.core.cache(), &mut reports);
809
810 let matched = queried
811 .find_report(&self.core.cache(), &reports)?
812 .filter(|report| {
813 !coverage
814 .withheld()
815 .iter()
816 .any(|withheld| withheld.venue_order_id == report.venue_order_id)
817 });
818 let mut stray_rows = queried.has_stray_report(&self.core.cache(), &reports);
819
820 if let Some(mut report) = matched {
821 if is_unpriced_terminal_report(&report) {
825 let fills = self
826 .http
827 .request_fill_reports(account_id, Some(report.instrument_id), None, None)
828 .await;
829 let page = fills.as_deref().unwrap_or_default();
830
831 if let Err(covered) = price_from_fills(&mut report, cached.as_ref(), page) {
832 fills?;
833 anyhow::bail!(
834 "Order {} executed per the order history with fills covering {covered} \
835 of {}; deferring until the fills feed prices it",
836 report.venue_order_id,
837 report.filled_qty,
838 );
839 }
840 }
841
842 return Ok(Some(report));
843 }
844
845 let Some(order) = cached else {
848 if stray_rows {
849 anyhow::bail!(
850 "No report names order {:?}, but a venue row of another venue order carries \
851 its client order ID; deferring rather than reporting it missing",
852 queried.client_order_id,
853 );
854 }
855 return absent_unless_unread(
856 &coverage,
857 cmd.venue_order_id,
858 None,
859 &status_command_label(cmd, cmd.venue_order_id),
860 );
861 };
862
863 let order_ids: Vec<String> = queried
865 .venue_order_id
866 .map(|id| id.to_string())
867 .into_iter()
868 .collect();
869 let cli_ord_ids: Vec<String> = venue_client_order_ids(&order.client_order_id()).collect();
870
871 let mut recent_reports = self
872 .http
873 .request_orders_status_reports(account_id, &order_ids, &cli_ord_ids)
874 .await?;
875 name_reports_by_cached_order(&self.core.cache(), &mut recent_reports);
876
877 let matched_recent = queried.find_report(&self.core.cache(), &recent_reports)?;
878 stray_rows |= queried.has_stray_report(&self.core.cache(), &recent_reports);
879
880 if matched_recent
882 .as_ref()
883 .is_some_and(|report| report.order_status != OrderStatus::Filled)
884 {
885 return Ok(matched_recent);
886 }
887
888 let now = Timestamp::now();
889 let start = now - Duration::from_secs(5 * 60);
890 let mut fills = self
891 .http
892 .request_fill_reports(
893 account_id,
894 Some(order.instrument_id()),
895 Some(start),
896 Some(now),
897 )
898 .await?;
899 name_fills_by_cached_order(&self.core.cache(), &mut fills);
900
901 let synthesized =
902 synthesize_filled_order_status_report(&self.core.cache(), &queried, &order, &fills);
903
904 match (synthesized, matched_recent) {
905 (Some(report), _) => Ok(Some(report)),
906 (None, Some(_)) => anyhow::bail!(
908 "Order {} fully executed in the orders-status window without visible \
909 fills; deferring until the fills feed prices it",
910 order.client_order_id(),
911 ),
912 (None, None) if stray_rows || queried.has_stray_fill(&self.core.cache(), &fills) => {
913 anyhow::bail!(
914 "No report names order {}, yet a venue row or fill that may be its own carries \
915 its client order ID; deferring rather than reporting it missing",
916 order.client_order_id(),
917 )
918 }
919 (None, None) => absent_unless_unread(
920 &coverage,
921 cmd.venue_order_id.or(order.venue_order_id()),
922 Some(earliest_venue_time(&order)),
923 order.client_order_id().as_str(),
924 ),
925 }
926 }
927
928 async fn generate_order_status_reports(
929 &self,
930 cmd: &GenerateOrderStatusReports,
931 ) -> anyhow::Result<Vec<OrderStatusReport>> {
932 log::debug!(
933 "Generating order status reports: instrument_id={:?}, open_only={}",
934 cmd.instrument_id,
935 cmd.open_only
936 );
937
938 let account_id = self.core.account_id;
939 let start = cmd.start.map(Timestamp::from);
940 let end = cmd.end.map(Timestamp::from);
941 let mut reports = self
942 .http
943 .request_order_status_reports(account_id, cmd.instrument_id, start, end, cmd.open_only)
944 .await?;
945
946 if reports.iter().any(is_unpriced_terminal_report) {
951 let fills = match self
954 .http
955 .request_fill_reports(account_id, cmd.instrument_id, None, None)
956 .await
957 {
958 Ok(fills) => fills,
959 Err(e) => {
960 log::warn!("Failed to read fills to price executed history orders: {e}");
961 Vec::new()
962 }
963 };
964 let cache = self.core.cache();
965 reports.retain_mut(|report| {
966 if !is_unpriced_terminal_report(report) {
967 return true;
968 }
969
970 let cached = cached_order_for_report(&cache, report);
971
972 match price_from_fills(report, cached.as_ref(), &fills) {
973 Ok(()) => true,
974 Err(covered) => {
975 log::warn!(
976 "Withholding executed order {} from the bulk response: fills cover \
977 {covered} of {}",
978 report.venue_order_id,
979 report.filled_qty,
980 );
981 false
982 }
983 }
984 });
985 }
986
987 if cmd.open_only {
988 let (extension, _) = self
989 .reports_for_open_orders_absent_from_venue(account_id, cmd.instrument_id, &reports)
990 .await?;
991
992 let (window_only, window_stated) = fold_window_into_venue_read(&mut reports, extension);
993
994 reports.retain(|report| {
998 let withhold = window_stated.contains(&report.venue_order_id)
999 && report.order_status == OrderStatus::Filled;
1000
1001 if withhold {
1002 log::warn!(
1003 "Withholding fully executed order {} from the bulk response: the \
1004 orders-status window carries no fill price",
1005 report.venue_order_id,
1006 );
1007 }
1008 !withhold
1009 });
1010
1011 for report in window_only {
1012 if report.order_status == OrderStatus::Filled {
1013 log::warn!(
1014 "Withholding fully executed order {} from the bulk response: the \
1015 orders-status window carries no fill price",
1016 report.venue_order_id,
1017 );
1018 continue;
1019 }
1020
1021 reports.push(report);
1022 }
1023 }
1024
1025 name_reports_by_cached_order(&self.core.cache(), &mut reports);
1026 Ok(reports)
1027 }
1028
1029 async fn generate_fill_reports(
1030 &self,
1031 cmd: GenerateFillReports,
1032 ) -> anyhow::Result<Vec<FillReport>> {
1033 log::debug!(
1034 "Generating fill reports: instrument_id={:?}",
1035 cmd.instrument_id
1036 );
1037
1038 let account_id = self.core.account_id;
1039 let start = cmd.start.map(Timestamp::from);
1040 let end = cmd.end.map(Timestamp::from);
1041 let mut reports = self
1042 .http
1043 .request_fill_reports(account_id, cmd.instrument_id, start, end)
1044 .await?;
1045
1046 if let Some(venue_order_id) = cmd.venue_order_id {
1047 reports.retain(|report| report.venue_order_id == venue_order_id);
1048 }
1049
1050 name_fills_by_cached_order(&self.core.cache(), &mut reports);
1051 Ok(reports)
1052 }
1053
1054 async fn generate_position_status_reports(
1055 &self,
1056 cmd: &GeneratePositionStatusReports,
1057 ) -> anyhow::Result<Vec<PositionStatusReport>> {
1058 log::debug!(
1059 "Generating position status reports: instrument_id={:?}",
1060 cmd.instrument_id
1061 );
1062
1063 let account_id = self.core.account_id;
1064 self.http
1065 .request_position_status_reports(account_id, cmd.instrument_id)
1066 .await
1067 }
1068
1069 async fn generate_mass_status(
1070 &self,
1071 lookback_mins: Option<u64>,
1072 ) -> anyhow::Result<Option<ExecutionMassStatus>> {
1073 log::debug!("Generating mass status: lookback_mins={lookback_mins:?}");
1074
1075 let ts_init = self.clock.get_time_ns();
1076 let lookback_start = lookback_mins.map(|mins| {
1079 let nanos = mins.saturating_mul(60).saturating_mul(1_000_000_000);
1080 ts_init.saturating_sub(DurationNanos::new(nanos))
1081 });
1082 let start = lookback_start.map(Timestamp::from);
1083 let account_id = self.core.account_id;
1084
1085 let (mut order_reports, orders_complete, skipped_orders) = match self
1091 .http
1092 .request_order_status_reports_checked(account_id, None, start, None, false)
1093 .await
1094 {
1095 Ok((reports, coverage)) => {
1096 let complete = coverage.is_complete();
1097 let skipped: Vec<VenueOrderId> = coverage.skipped().iter().copied().collect();
1098 (reports, complete, skipped)
1099 }
1100 Err(e) if is_refused_history_read(&e) => {
1101 log::warn!(
1102 "Order history read refused for mass status, reading open orders only and \
1103 marking the set incomplete: {e}"
1104 );
1105 let (reports, _) = self
1106 .http
1107 .request_order_status_reports_checked(account_id, None, start, None, true)
1108 .await?;
1109 (reports, false, Vec::new())
1110 }
1111 Err(e) => return Err(e),
1112 };
1113 let mut from_venue_read: HashSet<VenueOrderId> = order_reports
1116 .iter()
1117 .map(|report| report.venue_order_id)
1118 .collect();
1119
1120 let (extension, mut extension_withheld) = self
1121 .reports_for_open_orders_absent_from_venue(account_id, None, &order_reports)
1122 .await?;
1123
1124 let (window_only, window_stated) =
1125 fold_window_into_venue_read(&mut order_reports, extension);
1126
1127 order_reports.retain(|report| {
1132 let withhold = window_stated.contains(&report.venue_order_id)
1133 && report.order_status == OrderStatus::Filled;
1134
1135 if withhold {
1136 log::warn!(
1137 "Withholding fully executed order {} from mass status: the orders-status \
1138 window carries no fill price",
1139 report.venue_order_id,
1140 );
1141 extension_withheld = true;
1142 }
1143 !withhold
1144 });
1145
1146 for venue_order_id in &window_stated {
1147 from_venue_read.remove(venue_order_id);
1148 }
1149
1150 for report in window_only {
1151 if report.order_status == OrderStatus::Filled {
1152 log::warn!(
1153 "Withholding fully executed order {} from mass status: the orders-status \
1154 window carries no fill price",
1155 report.venue_order_id,
1156 );
1157 extension_withheld = true;
1158 continue;
1159 }
1160
1161 order_reports.push(report);
1162 }
1163
1164 let orders_complete = orders_complete && !extension_withheld;
1165
1166 let (mut fill_reports, fills_complete) = self
1167 .http
1168 .request_fill_reports_checked(account_id, None, start, None)
1169 .await?;
1170
1171 let mut withheld = false;
1185 let mut withheld_fills: HashSet<VenueOrderId> = HashSet::new();
1186 {
1187 let cache = self.core.cache();
1188 order_reports.retain_mut(|report| {
1189 if !from_venue_read.contains(&report.venue_order_id)
1190 || !is_unpriced_terminal_report(report)
1191 {
1192 return true;
1193 }
1194
1195 let cached = cached_order_for_report(&cache, report);
1196
1197 match price_from_fills(report, cached.as_ref(), &fill_reports) {
1198 Ok(()) => true,
1199 Err(covered) => {
1200 log::warn!(
1201 "Withholding executed order {} from mass status: fills cover \
1202 {covered} of {}; {}",
1203 report.venue_order_id,
1204 report.filled_qty,
1205 if cached.is_some() {
1206 "its page fills stay for the cached order"
1207 } else {
1208 "its page fills are withheld with it"
1209 },
1210 );
1211 withheld = true;
1212
1213 if cached.is_none() {
1214 withheld_fills.insert(report.venue_order_id);
1215 }
1216 false
1217 }
1218 }
1219 });
1220 }
1221 fill_reports.retain(|fill| !withheld_fills.contains(&fill.venue_order_id));
1222 {
1223 let cache = self.core.cache();
1224 let mut dropped: HashMap<VenueOrderId, usize> = HashMap::new();
1225 fill_reports.retain(|fill| {
1226 let drop = skipped_orders.contains(&fill.venue_order_id)
1227 && cache.client_order_id(&fill.venue_order_id).is_none()
1228 && !fill
1229 .client_order_id
1230 .is_some_and(|id| cache.order_exists(&id))
1231 && !order_reports
1232 .iter()
1233 .any(|report| report.venue_order_id == fill.venue_order_id);
1234
1235 if drop {
1236 *dropped.entry(fill.venue_order_id).or_default() += 1;
1237 }
1238 !drop
1239 });
1240
1241 for (venue_order_id, count) in &dropped {
1242 log::warn!(
1243 "Withholding {count} page fill(s) of uncached order {venue_order_id} from mass \
1244 status: a skipped history row left the order without a report"
1245 );
1246 }
1247 }
1248 let orders_complete = orders_complete && !withheld;
1249
1250 let position_reports = self
1251 .http
1252 .request_position_status_reports(account_id, None)
1253 .await?;
1254
1255 let orders_complete = if lookback_start.is_none() {
1270 let held: HashSet<InstrumentId> = position_reports
1271 .iter()
1272 .map(|report| report.instrument_id)
1273 .collect();
1274 let netted: HashSet<VenueOrderId> = {
1275 let cache = self.core.cache();
1276 order_reports
1277 .iter()
1278 .filter(|report| {
1279 from_venue_read.contains(&report.venue_order_id)
1280 && !held.contains(&report.instrument_id)
1281 && cached_order_for_report(&cache, report).is_none()
1282 })
1283 .map(|report| report.venue_order_id)
1284 .collect()
1285 };
1286 let candidates: HashMap<VenueOrderId, InstrumentId> = order_reports
1287 .iter()
1288 .filter(|report| {
1289 netted.contains(&report.venue_order_id)
1290 && matches!(
1291 report.order_status,
1292 OrderStatus::Filled
1293 | OrderStatus::Canceled
1294 | OrderStatus::Expired
1295 | OrderStatus::Voided
1296 )
1297 })
1298 .map(|report| (report.venue_order_id, report.instrument_id))
1299 .collect();
1300
1301 let mut net: HashMap<InstrumentId, Decimal> = HashMap::new();
1302
1303 for fill in fill_reports
1304 .iter()
1305 .filter(|fill| netted.contains(&fill.venue_order_id))
1306 {
1307 let qty = fill.last_qty.as_decimal();
1308 let signed = match fill.order_side {
1309 OrderSide::Buy => qty,
1310 OrderSide::Sell => -qty,
1311 };
1312 *net.entry(fill.instrument_id).or_default() += signed;
1313 }
1314 net.retain(|instrument_id, net| {
1315 !net.is_zero() && candidates.values().any(|id| id == instrument_id)
1316 });
1317
1318 if net.is_empty() {
1319 orders_complete
1320 } else {
1321 for (instrument_id, net) in &net {
1322 log::warn!(
1323 "Withholding terminal orders on {instrument_id} from mass status: the venue \
1324 reports it flat but the fills of orders the cache does not hold net to \
1325 {net}, so reconciliation would open a position; marking the set incomplete",
1326 );
1327 }
1328 let withheld_flat: HashSet<VenueOrderId> = candidates
1329 .iter()
1330 .filter(|(_, instrument_id)| net.contains_key(instrument_id))
1331 .map(|(venue_order_id, _)| *venue_order_id)
1332 .collect();
1333 order_reports.retain(|report| !withheld_flat.contains(&report.venue_order_id));
1334 fill_reports.retain(|fill| !withheld_flat.contains(&fill.venue_order_id));
1335 false
1336 }
1337 } else {
1338 orders_complete
1339 };
1340
1341 let mut mass_status = ExecutionMassStatus::new(
1342 self.core.client_id,
1343 self.core.account_id,
1344 *KRAKEN_VENUE,
1345 ts_init,
1346 None,
1347 );
1348 {
1349 let cache = self.core.cache();
1350 name_reports_by_cached_order(&cache, &mut order_reports);
1351 name_fills_by_cached_order(&cache, &mut fill_reports);
1352 }
1353 mass_status.add_order_reports(order_reports);
1354 mass_status.add_fill_reports(fill_reports);
1355 mass_status.add_position_reports(position_reports);
1356 mass_status.set_report_window(lookback_start, orders_complete && fills_complete);
1358
1359 Ok(Some(mass_status))
1360 }
1361
1362 fn query_account(&self, cmd: QueryAccount) -> anyhow::Result<()> {
1363 log::debug!("Querying account: {cmd}");
1364
1365 let account_id = self.core.account_id;
1366 let http = self.http.clone();
1367 let emitter = self.emitter.clone();
1368
1369 self.spawn_task("query_account", async move {
1370 let account_state = http.request_account_state(account_id).await?;
1371 emitter.emit_account_state(
1372 account_state.balances.clone(),
1373 account_state.margins.clone(),
1374 account_state.is_reported,
1375 account_state.ts_event,
1376 account_state.info,
1377 );
1378 Ok(())
1379 });
1380
1381 Ok(())
1382 }
1383
1384 fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
1385 log::debug!("Querying order: {cmd}");
1386
1387 let venue_order_id = cmd
1388 .venue_order_id
1389 .context("venue_order_id required for query_order")?;
1390 let cached_client_order_id = self.core.cache().client_order_id(&venue_order_id).copied();
1392 let account_id = self.core.account_id;
1393 let instrument_id = cmd.instrument_id;
1394 let http = self.http.clone();
1395 let emitter = self.emitter.clone();
1396
1397 self.spawn_task("query_order", async move {
1398 let reports = http
1401 .request_order_status_reports(account_id, Some(instrument_id), None, None, true)
1402 .await
1403 .context("Failed to query order")?;
1404
1405 match reports
1406 .into_iter()
1407 .find(|r| r.venue_order_id == venue_order_id)
1408 {
1409 Some(mut report) => {
1410 if let Some(client_order_id) = cached_client_order_id {
1411 report.client_order_id = Some(client_order_id);
1412 }
1413 emitter.send_order_status_report(report);
1414 }
1415 None => log::warn!(
1416 "No open order {venue_order_id} found for {instrument_id}; no report emitted"
1417 ),
1418 }
1419 Ok(())
1420 });
1421
1422 Ok(())
1423 }
1424
1425 fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
1426 let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
1427 self.submit_single_order(&order, "submit_order");
1428 Ok(())
1429 }
1430
1431 fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1432 let orders = self.core.get_orders_for_list(&cmd.order_list)?;
1433
1434 log::debug!(
1435 "Submitting order list: order_list_id={}, count={}",
1436 cmd.order_list.id,
1437 orders.len()
1438 );
1439
1440 if let Some(reason) = orders
1442 .iter()
1443 .filter(|order| !order.is_closed())
1444 .find_map(|order| validate_order(order).err())
1445 {
1446 for order in orders.iter().filter(|order| !order.is_closed()) {
1447 self.emitter.emit_order_denied(order, &reason.to_string());
1448 }
1449 return Ok(());
1450 }
1451
1452 let mut order_tuples = Vec::with_capacity(orders.len());
1453 let mut order_meta = Vec::with_capacity(orders.len());
1454
1455 for order in &orders {
1456 if order.is_closed() {
1457 log::warn!(
1458 "Cannot submit closed order: client_order_id={}",
1459 order.client_order_id()
1460 );
1461 continue;
1462 }
1463
1464 if order.order_type() == OrderType::Market {
1467 self.submit_single_order(order, "submit_order_list");
1468 continue;
1469 }
1470
1471 let client_order_id = order.client_order_id();
1472 self.register_order_identity(order);
1473 self.emitter.emit_order_submitted(order);
1474
1475 order_tuples.push((
1476 order.instrument_id(),
1477 client_order_id,
1478 order.order_side(),
1479 order.order_type(),
1480 order.quantity(),
1481 order.time_in_force(),
1482 order.price(),
1483 order.trigger_price(),
1484 order.trigger_type(),
1485 order.is_reduce_only(),
1486 order.is_post_only(),
1487 ));
1488
1489 order_meta.push((order.strategy_id(), order.instrument_id(), client_order_id));
1490 }
1491
1492 if order_tuples.is_empty() {
1493 return Ok(());
1494 }
1495
1496 let http = self.http.clone();
1497 let emitter = self.emitter.clone();
1498 let clock = self.clock;
1499 let dispatch_state = self.ws_dispatch_state.clone();
1500
1501 self.spawn_task("submit_order_list", async move {
1502 let results = http.send_order_batches(order_tuples).await;
1503 for (result, (strategy_id, instrument_id, client_order_id)) in
1504 results.into_iter().zip(&order_meta)
1505 {
1506 let outcome = match result {
1507 Ok(item) => command_failure_from_futures_batch_item(item),
1508 Err(e) => Err(command_failure_from_futures_batch_error(&e)),
1509 };
1510
1511 match outcome {
1512 Ok(()) => {}
1513 Err(CommandFailure::Ambiguous(reason)) => {
1514 log::warn!(
1515 "submit_order_list outcome is ambiguous for client_order_id={client_order_id}: {reason}"
1516 );
1517 }
1518 Err(
1519 CommandFailure::NotSent(reason)
1520 | CommandFailure::VenueRejected(reason),
1521 ) => {
1522 let ts_event = clock.get_time_ns();
1523 let error_msg =
1524 format!("submit_order_list batch item rejected: {reason}");
1525 dispatch_state.cleanup_terminal(client_order_id);
1526 emitter.emit_order_rejected_event(
1527 *strategy_id,
1528 *instrument_id,
1529 *client_order_id,
1530 &error_msg,
1531 ts_event,
1532 reason == "postWouldExecute",
1533 );
1534 }
1535 }
1536 }
1537 Ok(())
1538 });
1539
1540 Ok(())
1541 }
1542
1543 fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
1544 self.modify_single_order(&cmd);
1545 Ok(())
1546 }
1547
1548 fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1549 self.cancel_single_order(&cmd);
1550 Ok(())
1551 }
1552
1553 fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
1554 let instrument_id = cmd.instrument_id;
1555
1556 if cmd.order_side.is_none() {
1557 log::debug!("Canceling all orders: instrument_id={instrument_id} (bulk)");
1558
1559 let http = self.http.clone();
1560 let symbol = instrument_id.symbol.to_string();
1561
1562 self.spawn_task("cancel_all_orders", async move {
1563 match http.inner.cancel_all_orders(Some(symbol)).await {
1564 Ok(response) => {
1565 if response.result != KrakenApiResult::Success
1566 && response.cancel_status.cancelled_orders.is_empty()
1567 {
1568 log::warn!(
1569 "Cancel-all failed without per-order results, awaiting reconciliation: status={}",
1570 response.cancel_status.status
1571 );
1572 }
1573 }
1574 Err(e) => match command_failure_from_cancel_error(e) {
1575 CommandFailure::NotSent(reason) => {
1576 log::warn!("Cancel-all failed local validation: {reason}");
1577 }
1578 CommandFailure::Ambiguous(reason)
1579 | CommandFailure::VenueRejected(reason) => {
1580 log::warn!(
1581 "Cancel-all ambiguous failure, awaiting reconciliation: {reason}"
1582 );
1583 }
1584 },
1585 }
1586 Ok(())
1587 });
1588
1589 return Ok(());
1590 }
1591
1592 log::debug!(
1593 "Canceling all orders: instrument_id={instrument_id}, side={:?}",
1594 cmd.order_side
1595 );
1596
1597 let cancels: Vec<CancelOrder> = {
1600 let cache = self.core.cache();
1601 let ts_init = self.clock.get_time_ns();
1602 let correlation_id = cmd.correlation_id.or(Some(cmd.command_id));
1603
1604 let mut seen = HashSet::new();
1607
1608 cache
1609 .orders_open(None, Some(&instrument_id), None, None, None)
1610 .into_iter()
1611 .chain(cache.orders_inflight(None, Some(&instrument_id), None, None, None))
1612 .filter(|order| Some(order.order_side()) == cmd.order_side)
1613 .filter(|order| seen.insert(order.client_order_id()))
1614 .map(|order| {
1615 CancelOrder::new(
1616 cmd.trader_id,
1617 cmd.client_id,
1618 order.strategy_id(),
1620 order.instrument_id(),
1621 order.client_order_id(),
1622 order.venue_order_id(),
1623 UUID4::new(),
1624 ts_init,
1625 cmd.params.clone(),
1626 correlation_id,
1627 )
1628 })
1629 .collect()
1630 };
1631
1632 if cancels.is_empty() {
1633 log::debug!("No open orders to cancel for {instrument_id}");
1634 return Ok(());
1635 }
1636
1637 let http = self.http.clone();
1638 let emitter = self.emitter.clone();
1639 let clock = self.clock;
1640
1641 self.spawn_task("cancel_all_orders_by_side", async move {
1642 batch_cancel_orders_for_futures(&http, &emitter, clock, &cancels).await;
1643 Ok(())
1644 });
1645
1646 Ok(())
1647 }
1648
1649 fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
1650 log::debug!(
1651 "Batch canceling orders: instrument_id={}, count={}",
1652 cmd.instrument_id,
1653 cmd.cancels.len()
1654 );
1655
1656 let http = self.http.clone();
1657 let emitter = self.emitter.clone();
1658 let clock = self.clock;
1659 let cancels = cmd.cancels;
1660
1661 self.spawn_task("batch_cancel_orders", async move {
1662 batch_cancel_orders_for_futures(&http, &emitter, clock, &cancels).await;
1663 Ok(())
1664 });
1665
1666 Ok(())
1667 }
1668}
1669
1670#[derive(Debug, Clone)]
1671struct CancelRequestContext {
1672 command_id: UUID4,
1673 strategy_id: StrategyId,
1674 instrument_id: InstrumentId,
1675 client_order_id: ClientOrderId,
1676 cli_ord_id: String,
1679 venue_order_id: Option<VenueOrderId>,
1680}
1681
1682async fn cancel_order_for_futures(
1683 http: &KrakenFuturesHttpClient,
1684 _account_id: AccountId,
1685 instrument_id: InstrumentId,
1686 client_order_id: Option<ClientOrderId>,
1687 venue_order_id: Option<VenueOrderId>,
1688) -> Result<(), CommandFailure> {
1689 http.get_cached_instrument(&instrument_id.symbol.inner())
1690 .ok_or_else(|| {
1691 CommandFailure::not_sent(InstrumentLookupError::not_found(instrument_id).to_string())
1692 })?;
1693
1694 let (order_id, cli_ord_id) =
1695 order_identifier(client_order_id.as_ref(), venue_order_id.as_ref());
1696
1697 if order_id.is_none() && cli_ord_id.is_none() {
1698 return Err(CommandFailure::not_sent(
1699 "Either client_order_id or venue_order_id must be provided",
1700 ));
1701 }
1702
1703 let response = http
1704 .inner
1705 .cancel_order(order_id, cli_ord_id)
1706 .await
1707 .map_err(command_failure_from_cancel_error)?;
1708
1709 if response.result != KrakenApiResult::Success
1710 || response.cancel_status.status != KrakenSendStatus::Cancelled
1711 {
1712 return Err(CommandFailure::venue_rejected(format!(
1713 "cancel-order rejected: status={}",
1714 response.cancel_status.status
1715 )));
1716 }
1717
1718 Ok(())
1719}
1720
1721async fn batch_cancel_orders_for_futures(
1722 http: &KrakenFuturesHttpClient,
1723 emitter: &ExecutionEventEmitter,
1724 clock: &'static AtomicTime,
1725 cancels: &[CancelOrder],
1726) {
1727 let mut contexts = Vec::new();
1728 let mut items = Vec::new();
1729
1730 for cancel in cancels {
1731 match batch_cancel_item_for_futures(http, cancel) {
1732 Ok((context, item)) => {
1733 contexts.push(context);
1734 items.push(item);
1735 }
1736 Err(CommandFailure::NotSent(reason)) => {
1737 emitter.emit_order_cancel_denied_event(
1738 cancel.strategy_id,
1739 cancel.instrument_id,
1740 cancel.client_order_id,
1741 cancel.venue_order_id,
1742 &reason,
1743 clock.get_time_ns(),
1744 Some(cancel.command_id),
1745 );
1746 }
1747 Err(CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason)) => {
1748 log::warn!(
1749 "Batch cancel command ambiguous failure for {}, awaiting reconciliation: {reason}",
1750 cancel.client_order_id
1751 );
1752 }
1753 }
1754 }
1755
1756 let mut offset = 0;
1757 while offset < items.len() {
1758 let end = offset + batch_cancel_len(&contexts[offset..]);
1759 let item_chunk = &items[offset..end];
1760 let context_chunk = &contexts[offset..end];
1761 offset = end;
1762
1763 let response = match http
1764 .inner
1765 .cancel_order_items_batch(item_chunk.to_vec())
1766 .await
1767 {
1768 Ok(response) => response,
1769 Err(e) => {
1770 handle_batch_cancel_failure(
1771 command_failure_from_cancel_error(e),
1772 context_chunk,
1773 emitter,
1774 clock,
1775 );
1776 continue;
1777 }
1778 };
1779
1780 if response.batch_status.is_empty() {
1781 if response.result != KrakenApiResult::Success {
1782 let reason = response.error.as_deref().unwrap_or("Unknown error");
1783 log::warn!(
1784 "Batch cancel failed without per-order results, awaiting reconciliation: {reason}"
1785 );
1786 }
1787 continue;
1788 }
1789
1790 if response.batch_status.len() != context_chunk.len() {
1791 log::warn!(
1792 "Batch cancel returned {} per-order result(s) for {} request(s); unmatched results await reconciliation",
1793 response.batch_status.len(),
1794 context_chunk.len()
1795 );
1796 }
1797
1798 for (index, status) in response.batch_status.iter().enumerate() {
1799 let Some(cancel_status) = batch_cancel_status(status) else {
1800 log::warn!("Batch cancel result without status at index {index}");
1801 continue;
1802 };
1803
1804 if cancel_status == KrakenSendStatus::Cancelled {
1805 continue;
1806 }
1807
1808 let Some(context) = batch_cancel_context(status, context_chunk, index) else {
1809 log::warn!(
1810 "Batch cancel rejected item without matching request context at index {index}: status={cancel_status}"
1811 );
1812 continue;
1813 };
1814
1815 emitter.emit_order_cancel_rejected_event(
1816 context.strategy_id,
1817 context.instrument_id,
1818 context.client_order_id,
1819 context.venue_order_id,
1820 &format!("batch-cancel rejected: status={cancel_status}"),
1821 clock.get_time_ns(),
1822 Some(context.command_id),
1823 );
1824 }
1825 }
1826}
1827
1828fn batch_cancel_len(contexts: &[CancelRequestContext]) -> usize {
1829 let mut venue_ids = HashSet::new();
1830 let mut client_ids = HashSet::new();
1831 contexts
1832 .iter()
1833 .take(FUTURES_BATCH_CANCEL_LIMIT)
1834 .take_while(|context| {
1835 context.venue_order_id.is_none_or(|id| venue_ids.insert(id))
1836 && client_ids.insert(context.client_order_id)
1837 })
1838 .count()
1839}
1840
1841fn handle_batch_cancel_failure(
1842 failure: CommandFailure,
1843 context_chunk: &[CancelRequestContext],
1844 emitter: &ExecutionEventEmitter,
1845 clock: &AtomicTime,
1846) {
1847 match failure {
1848 CommandFailure::NotSent(reason) => {
1849 for cancel in context_chunk {
1850 emitter.emit_order_cancel_denied_event(
1851 cancel.strategy_id,
1852 cancel.instrument_id,
1853 cancel.client_order_id,
1854 cancel.venue_order_id,
1855 &reason,
1856 clock.get_time_ns(),
1857 Some(cancel.command_id),
1858 );
1859 }
1860 }
1861 CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason) => {
1862 log::warn!(
1863 "Batch cancel failed without per-order results, awaiting reconciliation: {reason}"
1864 );
1865 }
1866 }
1867}
1868
1869fn batch_cancel_item_for_futures(
1870 http: &KrakenFuturesHttpClient,
1871 cancel: &CancelOrder,
1872) -> Result<(CancelRequestContext, KrakenFuturesBatchCancelItem), CommandFailure> {
1873 http.get_cached_instrument(&cancel.instrument_id.symbol.inner())
1874 .ok_or_else(|| {
1875 CommandFailure::not_sent(
1876 InstrumentLookupError::not_found(cancel.instrument_id).to_string(),
1877 )
1878 })?;
1879
1880 let cli_ord_id = cancel.client_order_id.to_string();
1881 let item = if let Some(venue_order_id) = cancel.venue_order_id {
1882 KrakenFuturesBatchCancelItem::from_order_id(venue_order_id.to_string())
1883 } else {
1884 KrakenFuturesBatchCancelItem::from_client_order_id(cli_ord_id.clone())
1885 };
1886
1887 Ok((
1888 CancelRequestContext {
1889 command_id: cancel.command_id,
1890 strategy_id: cancel.strategy_id,
1891 instrument_id: cancel.instrument_id,
1892 client_order_id: cancel.client_order_id,
1893 cli_ord_id,
1894 venue_order_id: cancel.venue_order_id,
1895 },
1896 item,
1897 ))
1898}
1899
1900fn batch_cancel_status(status: &FuturesBatchCancelStatus) -> Option<KrakenSendStatus> {
1901 status
1902 .cancel_status
1903 .as_ref()
1904 .map(|cancel_status| cancel_status.status)
1905 .or(status.status)
1906}
1907
1908fn batch_cancel_context<'a>(
1909 status: &FuturesBatchCancelStatus,
1910 contexts: &'a [CancelRequestContext],
1911 index: usize,
1912) -> Option<&'a CancelRequestContext> {
1913 if let Some(order_id) = status.order_id.as_deref()
1914 && let Some(context) = contexts.iter().find(|context| {
1915 context
1916 .venue_order_id
1917 .is_some_and(|venue_order_id| venue_order_id.as_str() == order_id)
1918 })
1919 {
1920 return Some(context);
1921 }
1922
1923 if let Some(cli_ord_id) = status.cli_ord_id.as_deref()
1924 && let Some(context) = contexts
1925 .iter()
1926 .find(|context| context.cli_ord_id == cli_ord_id)
1927 {
1928 return Some(context);
1929 }
1930
1931 if index < contexts.len() && status.order_id.is_none() && status.cli_ord_id.is_none() {
1932 return contexts.get(index);
1933 }
1934
1935 None
1936}
1937
1938#[expect(
1939 clippy::too_many_arguments,
1940 reason = "Failure emission retains order identity and command correlation"
1941)]
1942fn handle_cancel_failure(
1943 emitter: &ExecutionEventEmitter,
1944 clock: &'static AtomicTime,
1945 strategy_id: StrategyId,
1946 instrument_id: InstrumentId,
1947 client_order_id: ClientOrderId,
1948 venue_order_id: Option<VenueOrderId>,
1949 failure: CommandFailure,
1950 causation_id: UUID4,
1951) {
1952 match failure {
1953 CommandFailure::VenueRejected(reason) => {
1954 emitter.emit_order_cancel_rejected_event(
1955 strategy_id,
1956 instrument_id,
1957 client_order_id,
1958 venue_order_id,
1959 &reason,
1960 clock.get_time_ns(),
1961 Some(causation_id),
1962 );
1963 }
1964 CommandFailure::NotSent(reason) => {
1965 emitter.emit_order_cancel_denied_event(
1966 strategy_id,
1967 instrument_id,
1968 client_order_id,
1969 venue_order_id,
1970 &reason,
1971 clock.get_time_ns(),
1972 Some(causation_id),
1973 );
1974 }
1975 CommandFailure::Ambiguous(reason) => {
1976 log::warn!(
1977 "Ambiguous cancel failure for {client_order_id}, awaiting reconciliation: {reason}"
1978 );
1979 }
1980 }
1981}
1982
1983impl KrakenFuturesExecutionClient {
1984 async fn reports_for_open_orders_absent_from_venue(
2001 &self,
2002 account_id: AccountId,
2003 instrument_id: Option<InstrumentId>,
2004 reported: &[OrderStatusReport],
2005 ) -> anyhow::Result<(Vec<OrderStatusReport>, bool)> {
2006 let mut order_ids = Vec::new();
2007 let mut queried_by_cli_ord_id = Vec::new();
2008
2009 {
2010 let cache = self.core.cache();
2011 for order in cache.orders_open(
2012 Some(&*KRAKEN_VENUE),
2013 instrument_id.as_ref(),
2014 None,
2015 None,
2016 None,
2017 ) {
2018 if product_type_from_symbol(order.instrument_id().symbol.inner().as_str())
2020 != KrakenProductType::Futures
2021 {
2022 continue;
2023 }
2024
2025 match order.venue_order_id() {
2026 Some(venue_order_id) => {
2027 let already_reported = reported
2028 .iter()
2029 .any(|report| report.venue_order_id == venue_order_id);
2030 if !already_reported {
2031 order_ids.push(venue_order_id.to_string());
2032 }
2033 }
2034 None => {
2035 queried_by_cli_ord_id.push(HeldOrder {
2036 client_order_id: order.client_order_id(),
2037 instrument_id: order.instrument_id(),
2038 side: order.order_side(),
2039 ts_init: order.ts_init(),
2040 });
2041 }
2042 }
2043 }
2044 }
2045
2046 if order_ids.is_empty() && queried_by_cli_ord_id.is_empty() {
2047 return Ok((Vec::new(), false));
2048 }
2049
2050 let cli_ord_ids: Vec<String> = queried_by_cli_ord_id
2051 .iter()
2052 .flat_map(|order| venue_client_order_ids(&order.client_order_id))
2053 .collect();
2054
2055 log::debug!(
2056 "Resolving {} venue order ID(s) and {} client order ID(s) from the orders-status window",
2057 order_ids.len(),
2058 cli_ord_ids.len(),
2059 );
2060
2061 let mut reports = Vec::new();
2062 for chunk in order_ids.chunks(FUTURES_ORDERS_STATUS_LIMIT) {
2063 reports.extend(
2064 self.http
2065 .request_orders_status_reports(account_id, chunk, &[])
2066 .await?,
2067 );
2068 }
2069
2070 for chunk in cli_ord_ids.chunks(FUTURES_ORDERS_STATUS_LIMIT) {
2071 reports.extend(
2072 self.http
2073 .request_orders_status_reports(account_id, &[], chunk)
2074 .await?,
2075 );
2076 }
2077
2078 let (mut attributed, withheld) = attribute_orders_status_reports(
2079 &self.core.cache(),
2080 &queried_by_cli_ord_id,
2081 latest_report_per_order(reports),
2082 );
2083
2084 if let Some(instrument_id) = instrument_id {
2087 attributed.retain(|report| report.instrument_id == instrument_id);
2088 }
2089
2090 Ok((attributed, withheld))
2091 }
2092}
2093
2094fn validate_order(order: &OrderAny) -> Result<(), OrderDeniedReason> {
2096 let len = order.client_order_id().as_str().len();
2097
2098 if len > KRAKEN_FUTURES_MAX_CLIENT_ORDER_ID_LEN {
2099 return Err(OrderDeniedReason::InvalidClientOrderId {
2100 detail: format!(
2101 "Kraken Futures accepts a client order ID of at most \
2102 {KRAKEN_FUTURES_MAX_CLIENT_ORDER_ID_LEN} characters, was {len}"
2103 ),
2104 });
2105 }
2106
2107 Ok(())
2108}
2109
2110fn cached_order_for_report(cache: &Cache, report: &OrderStatusReport) -> Option<OrderAny> {
2112 let client_order_id = cache.client_order_id(&report.venue_order_id)?;
2113 cache.order(client_order_id).map(|order| order.clone())
2114}
2115
2116struct QueriedOrder {
2131 venue_order_id: Option<VenueOrderId>,
2132 client_order_id: Option<ClientOrderId>,
2133 cached: Option<(InstrumentId, OrderSide, UnixNanos)>,
2134}
2135
2136impl QueriedOrder {
2137 fn new(cmd: &GenerateOrderStatusReport, cached: Option<&OrderAny>) -> Self {
2138 Self {
2139 venue_order_id: cmd
2140 .venue_order_id
2141 .or_else(|| cached.and_then(Order::venue_order_id)),
2142 client_order_id: cmd
2143 .client_order_id
2144 .or_else(|| cached.map(Order::client_order_id)),
2145 cached: cached
2146 .map(|order| (order.instrument_id(), order.order_side(), order.ts_init())),
2147 }
2148 }
2149
2150 fn echoes(
2153 &self,
2154 echoed: Option<ClientOrderId>,
2155 instrument_id: InstrumentId,
2156 side: OrderSide,
2157 placed: UnixNanos,
2158 ) -> bool {
2159 let echoes_id = echoed
2160 .zip(self.client_order_id)
2161 .is_some_and(|(echoed, queried)| {
2162 venue_client_order_ids(&queried).any(|id| id == echoed.as_str())
2163 });
2164
2165 echoes_id
2166 && self
2167 .cached
2168 .is_none_or(|(order_instrument, order_side, created)| {
2169 instrument_id == order_instrument
2170 && side == order_side
2171 && placed.saturating_add(ORDERS_STATUS_CLOCK_SKEW) >= created
2172 })
2173 }
2174
2175 fn indexed_for_another(&self, cache: &Cache, venue_order_id: &VenueOrderId) -> bool {
2177 cache
2178 .client_order_id(venue_order_id)
2179 .is_some_and(|owner| Some(*owner) != self.client_order_id)
2180 }
2181
2182 fn echoes_report(&self, cache: &Cache, report: &OrderStatusReport) -> bool {
2183 !self.indexed_for_another(cache, &report.venue_order_id)
2184 && report.order_side.is_some_and(|side| {
2185 self.echoes(
2186 report.client_order_id,
2187 report.instrument_id,
2188 side,
2189 report.ts_accepted,
2190 )
2191 })
2192 }
2193
2194 fn echoes_fill(&self, cache: &Cache, fill: &FillReport) -> bool {
2195 !self.indexed_for_another(cache, &fill.venue_order_id)
2196 && self.echoes(
2197 fill.client_order_id,
2198 fill.instrument_id,
2199 fill.order_side,
2200 fill.ts_event,
2201 )
2202 }
2203
2204 fn echo_is_another_order(
2208 &self,
2209 cache: &Cache,
2210 echoed: Option<ClientOrderId>,
2211 instrument_id: InstrumentId,
2212 side: OrderSide,
2213 placed: UnixNanos,
2214 ) -> bool {
2215 echoed
2216 .filter(|echoed| Some(*echoed) != self.client_order_id)
2217 .and_then(|echoed| cache.order(&echoed))
2218 .is_some_and(|other| {
2219 other.ts_submitted().is_some()
2220 && other.venue_order_id().is_none()
2221 && other.instrument_id() == instrument_id
2222 && other.order_side() == side
2223 && placed.saturating_add(ORDERS_STATUS_CLOCK_SKEW) >= other.ts_init()
2224 })
2225 }
2226
2227 fn report_may_be_another_order(&self, cache: &Cache, report: &OrderStatusReport) -> bool {
2228 report.order_side.is_some_and(|side| {
2229 self.echo_is_another_order(
2230 cache,
2231 report.client_order_id,
2232 report.instrument_id,
2233 side,
2234 report.ts_accepted,
2235 )
2236 })
2237 }
2238
2239 fn fill_may_be_another_order(&self, cache: &Cache, fill: &FillReport) -> bool {
2240 self.echo_is_another_order(
2241 cache,
2242 fill.client_order_id,
2243 fill.instrument_id,
2244 fill.order_side,
2245 fill.ts_event,
2246 )
2247 }
2248
2249 fn find_report(
2257 &self,
2258 cache: &Cache,
2259 reports: &[OrderStatusReport],
2260 ) -> anyhow::Result<Option<OrderStatusReport>> {
2261 if let Some(venue_order_id) = self.venue_order_id {
2262 return Ok(reports
2263 .iter()
2264 .find(|report| report.venue_order_id == venue_order_id)
2265 .cloned());
2266 }
2267
2268 let mut candidates = reports
2269 .iter()
2270 .filter(|report| self.echoes_report(cache, report));
2271 let Some(first) = candidates.next() else {
2272 return Ok(None);
2273 };
2274
2275 if candidates.any(|report| report.venue_order_id != first.venue_order_id) {
2276 anyhow::bail!(
2277 "Reports of several venue orders carry the client order ID of order {:?}; \
2278 deferring rather than taking one of them",
2279 self.client_order_id,
2280 );
2281 }
2282
2283 if let Some(shared) = reports.iter().find(|report| {
2284 self.echoes_report(cache, report) && self.report_may_be_another_order(cache, report)
2285 }) {
2286 anyhow::bail!(
2287 "Report of venue order {} carries {:?}, the full ID of another cached order and a \
2288 form of order {:?}; deferring until the cache ties the venue order to one of them",
2289 shared.venue_order_id,
2290 shared.client_order_id,
2291 self.client_order_id,
2292 );
2293 }
2294
2295 let mut report = first.clone();
2296 report.client_order_id = self.client_order_id;
2297 Ok(Some(report))
2298 }
2299
2300 fn has_stray_report(&self, cache: &Cache, reports: &[OrderStatusReport]) -> bool {
2303 self.venue_order_id.is_some_and(|venue_order_id| {
2304 reports.iter().any(|report| {
2305 report.venue_order_id != venue_order_id && self.echoes_report(cache, report)
2306 })
2307 })
2308 }
2309
2310 fn has_stray_fill(&self, cache: &Cache, fills: &[FillReport]) -> bool {
2314 fills.iter().any(|fill| {
2315 Some(fill.venue_order_id) != self.venue_order_id && self.echoes_fill(cache, fill)
2316 })
2317 }
2318}
2319
2320fn venue_client_order_ids(client_order_id: &ClientOrderId) -> impl Iterator<Item = String> {
2324 let full = client_order_id.to_string();
2325 let shortened = truncate_cl_ord_id(client_order_id);
2326 let shortened = (shortened != full).then_some(shortened);
2327 std::iter::once(full).chain(shortened)
2328}
2329
2330#[derive(Clone, Copy, Debug)]
2332struct HeldOrder {
2333 client_order_id: ClientOrderId,
2334 instrument_id: InstrumentId,
2335 side: OrderSide,
2336 ts_init: UnixNanos,
2337}
2338
2339fn name_reports_by_cached_order(cache: &Cache, reports: &mut [OrderStatusReport]) {
2343 for report in reports {
2344 if let Some(client_order_id) = cache.client_order_id(&report.venue_order_id) {
2345 report.client_order_id = Some(*client_order_id);
2346 }
2347 }
2348}
2349
2350fn name_fills_by_cached_order(cache: &Cache, fills: &mut [FillReport]) {
2353 for fill in fills {
2354 if let Some(client_order_id) = cache.client_order_id(&fill.venue_order_id) {
2355 fill.client_order_id = Some(*client_order_id);
2356 }
2357 }
2358}
2359
2360fn fold_window_into_venue_read(
2371 venue_read: &mut [OrderStatusReport],
2372 window: Vec<OrderStatusReport>,
2373) -> (Vec<OrderStatusReport>, HashSet<VenueOrderId>) {
2374 let positions: HashMap<VenueOrderId, usize> = venue_read
2375 .iter()
2376 .enumerate()
2377 .map(|(position, report)| (report.venue_order_id, position))
2378 .collect();
2379 let mut window_stated = HashSet::new();
2380
2381 let window_only = window
2382 .into_iter()
2383 .filter_map(|copy| {
2384 let Some(&position) = positions.get(©.venue_order_id) else {
2385 return Some(copy);
2386 };
2387 let report = &mut venue_read[position];
2388 report.client_order_id = copy.client_order_id;
2389
2390 if !report.order_status.is_closed() && supersedes(©, report) {
2391 report.order_status = copy.order_status;
2392 report.quantity = copy.quantity;
2393 report.filled_qty = copy.filled_qty;
2394 report.price = copy.price;
2395 report.avg_px = copy.avg_px;
2396 report.cancel_reason = copy.cancel_reason;
2397 report.ts_last = copy.ts_last;
2398 window_stated.insert(copy.venue_order_id);
2399 }
2400 None
2401 })
2402 .collect();
2403
2404 (window_only, window_stated)
2405}
2406
2407fn latest_report_per_order(reports: Vec<OrderStatusReport>) -> Vec<OrderStatusReport> {
2414 let mut latest: IndexMap<VenueOrderId, OrderStatusReport> =
2415 IndexMap::with_capacity(reports.len());
2416
2417 for report in reports {
2418 match latest.get(&report.venue_order_id) {
2419 Some(existing) if !supersedes(&report, existing) => {}
2420 _ => {
2421 latest.insert(report.venue_order_id, report);
2422 }
2423 }
2424 }
2425
2426 latest.into_values().collect()
2427}
2428
2429fn attribute_orders_status_reports(
2445 cache: &Cache,
2446 queried_by_cli_ord_id: &[HeldOrder],
2447 reports: Vec<OrderStatusReport>,
2448) -> (Vec<OrderStatusReport>, bool) {
2449 let mut held: HashMap<String, Option<HeldOrder>> = HashMap::new();
2451
2452 for order in queried_by_cli_ord_id {
2453 for echoed in venue_client_order_ids(&order.client_order_id) {
2454 held.entry(echoed)
2455 .and_modify(|named| *named = None)
2456 .or_insert(Some(*order));
2457 }
2458 }
2459
2460 let indexed =
2461 |report: &OrderStatusReport| cache.client_order_id(&report.venue_order_id).copied();
2462
2463 let mut unindexed: HashMap<ClientOrderId, HashSet<VenueOrderId>> = HashMap::new();
2464
2465 for report in &reports {
2466 if indexed(report).is_none()
2467 && let Some(echoed) = report.client_order_id
2468 {
2469 unindexed
2470 .entry(echoed)
2471 .or_default()
2472 .insert(report.venue_order_id);
2473 }
2474 }
2475
2476 let by_echoed_id = |report: &OrderStatusReport| -> Result<ClientOrderId, &'static str> {
2477 let echoed = report
2478 .client_order_id
2479 .ok_or("it carries no client order ID")?;
2480 if unindexed
2481 .get(&echoed)
2482 .is_none_or(|venue_order_ids| venue_order_ids.len() != 1)
2483 {
2484 return Err("several reports carry its client order ID");
2485 }
2486 let order = held
2487 .get(echoed.as_str())
2488 .ok_or("no order queried by client order ID holds its client order ID")?
2489 .ok_or("several queried orders hold its client order ID")?;
2490
2491 if report.instrument_id != order.instrument_id || report.order_side != Some(order.side) {
2492 return Err("its instrument or side is not the queried order's");
2493 }
2494
2495 if report.ts_accepted.saturating_add(ORDERS_STATUS_CLOCK_SKEW) < order.ts_init {
2496 return Err(
2497 "the venue placed it before the queried order's creation, beyond the clock skew \
2498 allowance; check the node clock if the order is recent",
2499 );
2500 }
2501
2502 Ok(order.client_order_id)
2503 };
2504
2505 let named: Vec<(OrderStatusReport, Result<ClientOrderId, &'static str>, bool)> = reports
2506 .into_iter()
2507 .map(|report| match indexed(&report) {
2508 Some(client_order_id) => (report, Ok(client_order_id), false),
2509 None => {
2510 let named = by_echoed_id(&report);
2511 (report, named, true)
2512 }
2513 })
2514 .collect();
2515
2516 let mut named_by_echo: HashMap<ClientOrderId, usize> = HashMap::new();
2518
2519 for (_, named, by_echo) in &named {
2520 if *by_echo && let Ok(client_order_id) = named {
2521 *named_by_echo.entry(*client_order_id).or_default() += 1;
2522 }
2523 }
2524
2525 let mut attributed = Vec::with_capacity(named.len());
2526 let mut withheld = false;
2527
2528 for (mut report, named, by_echo) in named {
2529 let named = match named {
2530 Ok(client_order_id)
2531 if by_echo && named_by_echo.get(&client_order_id).is_some_and(|n| *n > 1) =>
2532 {
2533 Err("several reports name the queried order it would be")
2534 }
2535 named => named,
2536 };
2537
2538 match named {
2539 Ok(client_order_id) => {
2540 report.client_order_id = Some(client_order_id);
2541 attributed.push(report);
2542 }
2543 Err(reason) => {
2544 log::warn!(
2545 "Withholding orders-status report {} with client order ID {:?}: {reason}",
2546 report.venue_order_id,
2547 report.client_order_id,
2548 );
2549 withheld = true;
2550 }
2551 }
2552 }
2553
2554 (attributed, withheld)
2555}
2556
2557fn is_refused_history_read(error: &anyhow::Error) -> bool {
2564 error
2565 .chain()
2566 .filter_map(|cause| cause.downcast_ref::<KrakenHttpError>())
2567 .any(|e| match e {
2568 KrakenHttpError::ApiError(_) => true,
2569 KrakenHttpError::NetworkError(message) => message.starts_with("HTTP error 429"),
2570 _ => false,
2571 })
2572}
2573
2574fn is_unpriced_terminal_report(report: &OrderStatusReport) -> bool {
2579 matches!(
2580 report.order_status,
2581 OrderStatus::Filled | OrderStatus::Canceled | OrderStatus::Expired | OrderStatus::Voided
2582 ) && !report.filled_qty.is_zero()
2583 && report.avg_px.is_none()
2584}
2585
2586fn price_from_fills(
2600 report: &mut OrderStatusReport,
2601 cached: Option<&OrderAny>,
2602 fills: &[FillReport],
2603) -> Result<(), Decimal> {
2604 let target = report.filled_qty.as_decimal();
2605 let order_fills: Vec<&FillReport> = fills
2606 .iter()
2607 .filter(|fill| fill.venue_order_id == report.venue_order_id)
2608 .collect();
2609 let total = |fills: &mut dyn Iterator<Item = &&FillReport>| {
2610 fills.fold((Decimal::ZERO, Decimal::ZERO), |(qty, notional), fill| {
2611 let fill_qty = fill.last_qty.as_decimal();
2612 (
2613 qty + fill_qty,
2614 notional + fill_qty * fill.last_px.as_decimal(),
2615 )
2616 })
2617 };
2618
2619 let (page_qty, page_notional) = total(&mut order_fills.iter());
2620
2621 if !target.is_zero() && page_qty == target {
2622 report.avg_px = Some(page_notional / target);
2623 return Ok(());
2624 }
2625
2626 let Some(order) = cached else {
2627 return Err(page_qty);
2628 };
2629 let recorded: HashSet<TradeId> = order.trade_ids().into_iter().copied().collect();
2630 let (new_qty, new_notional) = total(
2631 &mut order_fills
2632 .iter()
2633 .filter(|fill| !recorded.contains(&fill.trade_id)),
2634 );
2635 let cached_qty = order.filled_qty().as_decimal();
2636 let covered = cached_qty + new_qty;
2637
2638 if !target.is_zero() && covered == target {
2639 let cached_notional = order.avg_px().unwrap_or(Decimal::ZERO) * cached_qty;
2640 report.avg_px = Some((cached_notional + new_notional) / target);
2641 return Ok(());
2642 }
2643
2644 Err(covered.max(page_qty))
2645}
2646
2647fn synthesize_filled_order_status_report(
2648 cache: &Cache,
2649 queried: &QueriedOrder,
2650 order: &OrderAny,
2651 fills: &[FillReport],
2652) -> Option<OrderStatusReport> {
2653 let venue_order_id = queried.venue_order_id;
2654
2655 let mut matched: Vec<&FillReport> = match venue_order_id {
2659 Some(venue_order_id) => fills
2660 .iter()
2661 .filter(|fill| fill.venue_order_id == venue_order_id)
2662 .collect(),
2663 None => {
2664 let matched: Vec<&FillReport> = fills
2665 .iter()
2666 .filter(|fill| queried.echoes_fill(cache, fill))
2667 .collect();
2668 let first_venue_order_id = matched.first()?.venue_order_id;
2669
2670 if matched.iter().any(|fill| {
2671 fill.venue_order_id != first_venue_order_id
2672 || queried.fill_may_be_another_order(cache, fill)
2673 }) {
2674 return None;
2675 }
2676 matched
2677 }
2678 };
2679
2680 if matched.is_empty() {
2681 return None;
2682 }
2683
2684 matched.sort_by_key(|fill| fill.ts_event);
2685 let first_fill = *matched.first()?;
2686 let last_fill = *matched.last()?;
2687
2688 let total_filled = matched
2689 .iter()
2690 .fold(Decimal::ZERO, |acc, fill| acc + fill.last_qty.as_decimal());
2691 if total_filled < order.quantity().as_decimal() {
2692 return None;
2693 }
2694
2695 let total_notional = matched.iter().fold(Decimal::ZERO, |acc, fill| {
2696 acc + fill.last_qty.as_decimal() * fill.last_px.as_decimal()
2697 });
2698 let avg_px = if total_filled.is_zero() {
2699 None
2700 } else {
2701 Some(total_notional / total_filled)
2702 };
2703 let venue_order_id = venue_order_id.unwrap_or(first_fill.venue_order_id);
2704
2705 let mut report = OrderStatusReport::new(
2706 first_fill.account_id,
2707 order.instrument_id(),
2708 Some(order.client_order_id()),
2709 venue_order_id,
2710 order.order_side().into(),
2711 order.order_type(),
2712 order.time_in_force(),
2713 OrderStatus::Filled,
2714 order.quantity(),
2715 order.quantity(),
2716 first_fill.ts_event,
2717 last_fill.ts_event,
2718 last_fill.ts_init,
2719 None,
2720 );
2721 report.order_list_id = order.order_list_id();
2722 report.venue_position_id = matched.iter().rev().find_map(|fill| fill.venue_position_id);
2723 report.linked_order_ids = order
2724 .linked_order_ids()
2725 .map(|linked_order_ids| linked_order_ids.to_vec());
2726 report.parent_order_id = order.parent_order_id();
2727 report.expire_time = order.expire_time();
2728 report.price = order.price();
2729 report.trigger_price = order.trigger_price();
2730 report.trigger_type = order.trigger_type();
2731 report.avg_px = avg_px;
2732 report.display_qty = order.display_qty();
2733 report.post_only = order.is_post_only();
2734 report.reduce_only = order.is_reduce_only();
2735 Some(report)
2736}
2737
2738#[cfg(test)]
2739mod tests {
2740 use nautilus_core::{UUID4, UnixNanos};
2741 use nautilus_model::{
2742 enums::{LiquiditySide, OrderSide, OrderType, TimeInForce},
2743 identifiers::{
2744 AccountId, ClientOrderId, InstrumentId, StrategyId, TradeId, TraderId, VenueOrderId,
2745 },
2746 orders::OrderTestBuilder,
2747 reports::FillReport,
2748 types::{Currency, Money, Price, Quantity},
2749 };
2750 use rstest::rstest;
2751
2752 use super::*;
2753
2754 const TEST_INSTRUMENT_ID: &str = "PF_XBTUSD.KRAKEN";
2755
2756 #[rstest]
2757 #[case::limit(51, false, false, false, 50)]
2758 #[case::venue(3, true, false, false, 1)]
2759 #[case::client_alias(3, false, true, false, 1)]
2760 #[case::client_only(3, false, true, true, 1)]
2761 fn test_batch_cancel_len(
2762 #[case] count: usize,
2763 #[case] repeated_venue: bool,
2764 #[case] repeated_client: bool,
2765 #[case] client_only: bool,
2766 #[case] expected: usize,
2767 ) {
2768 let contexts: Vec<_> = (0..count)
2769 .map(|index| {
2770 let client_order_id =
2771 ClientOrderId::from(format!("C-{}", if repeated_client { 0 } else { index }));
2772
2773 CancelRequestContext {
2774 command_id: UUID4::new(),
2775 strategy_id: StrategyId::from("S-BATCH"),
2776 instrument_id: InstrumentId::from(TEST_INSTRUMENT_ID),
2777 client_order_id,
2778 cli_ord_id: client_order_id.to_string(),
2779 venue_order_id: (!client_only).then(|| {
2780 VenueOrderId::from(format!("V-{}", if repeated_venue { 0 } else { index }))
2781 }),
2782 }
2783 })
2784 .collect();
2785
2786 assert_eq!(batch_cancel_len(&contexts), expected);
2787 }
2788
2789 #[tokio::test]
2790 async fn test_cancel_order_for_futures_missing_cached_instrument_returns_canonical_error() {
2791 let http = KrakenFuturesHttpClient::default();
2792 let instrument_id = InstrumentId::from(TEST_INSTRUMENT_ID);
2793 let client_order_id = ClientOrderId::from("C-001");
2794 let venue_order_id = VenueOrderId::from("V-001");
2795
2796 let result = cancel_order_for_futures(
2797 &http,
2798 AccountId::from("KRAKEN-001"),
2799 instrument_id,
2800 Some(client_order_id),
2801 Some(venue_order_id),
2802 )
2803 .await;
2804
2805 match result {
2806 Err(CommandFailure::NotSent(reason)) => {
2807 assert_eq!(
2808 reason,
2809 InstrumentLookupError::not_found(instrument_id).to_string()
2810 );
2811 }
2812 _ => panic!("Expected local validation failure"),
2813 }
2814 }
2815
2816 #[rstest]
2817 fn test_batch_cancel_item_for_futures_missing_cached_instrument_returns_canonical_error() {
2818 let http = KrakenFuturesHttpClient::default();
2819 let instrument_id = InstrumentId::from(TEST_INSTRUMENT_ID);
2820 let cancel = CancelOrder::new(
2821 TraderId::from("TESTER-001"),
2822 None,
2823 StrategyId::from("S-001"),
2824 instrument_id,
2825 ClientOrderId::from("C-001"),
2826 Some(VenueOrderId::from("V-001")),
2827 UUID4::new(),
2828 UnixNanos::default(),
2829 None,
2830 None,
2831 );
2832
2833 let result = batch_cancel_item_for_futures(&http, &cancel);
2834
2835 match result {
2836 Err(CommandFailure::NotSent(reason)) => {
2837 assert_eq!(
2838 reason,
2839 InstrumentLookupError::not_found(instrument_id).to_string()
2840 );
2841 }
2842 _ => panic!("Expected local validation failure"),
2843 }
2844 }
2845
2846 fn make_fill(
2847 venue_order_id: &str,
2848 client_order_id: Option<&str>,
2849 quantity: &str,
2850 price: &str,
2851 ts_event: u64,
2852 ) -> FillReport {
2853 FillReport::new(
2854 AccountId::from("KRAKEN-001"),
2855 InstrumentId::from(TEST_INSTRUMENT_ID),
2856 VenueOrderId::from(venue_order_id),
2857 TradeId::from(format!("T-{ts_event}").as_str()),
2858 OrderSide::Buy,
2859 Quantity::from(quantity),
2860 Price::from(price),
2861 Money::from_decimal(Decimal::ZERO, Currency::USD()).unwrap(),
2862 LiquiditySide::Taker,
2863 client_order_id.map(ClientOrderId::from),
2864 None,
2865 UnixNanos::from(ts_event),
2866 UnixNanos::from(ts_event),
2867 None,
2868 )
2869 }
2870
2871 fn make_cmd(
2872 client_order_id: Option<&str>,
2873 venue_order_id: Option<&str>,
2874 ) -> GenerateOrderStatusReport {
2875 GenerateOrderStatusReport::new(
2876 UUID4::new(),
2877 UnixNanos::default(),
2878 Some(InstrumentId::from(TEST_INSTRUMENT_ID)),
2879 client_order_id.map(ClientOrderId::from),
2880 venue_order_id.map(VenueOrderId::from),
2881 None,
2882 None,
2883 )
2884 }
2885
2886 fn make_order(client_order_id: &str) -> OrderAny {
2887 OrderTestBuilder::new(OrderType::Market)
2888 .instrument_id(InstrumentId::from(TEST_INSTRUMENT_ID))
2889 .client_order_id(ClientOrderId::from(client_order_id))
2890 .side(OrderSide::Buy)
2891 .quantity(Quantity::from("100"))
2892 .time_in_force(TimeInForce::Ioc)
2893 .build()
2894 }
2895
2896 #[rstest]
2897 fn test_synthesize_filled_order_status_report_matches_full_fill_by_venue_order_id() {
2898 let order = make_order("O-123456");
2899 let cmd = make_cmd(Some("O-123456"), Some("KRAKEN-789"));
2900 let fills = vec![
2901 make_fill("KRAKEN-789", Some("O-123456"), "40", "50000.0", 1),
2902 make_fill("KRAKEN-789", Some("O-123456"), "60", "50010.0", 2),
2903 make_fill("KRAKEN-OTHER", Some("O-123456"), "999", "1.0", 3),
2904 ];
2905
2906 let report = synthesize_filled_order_status_report(
2907 &Cache::default(),
2908 &QueriedOrder::new(&cmd, Some(&order)),
2909 &order,
2910 &fills,
2911 )
2912 .expect("expected a filled report");
2913
2914 assert_eq!(report.venue_order_id, VenueOrderId::from("KRAKEN-789"));
2915 assert_eq!(
2916 report.client_order_id,
2917 Some(ClientOrderId::from("O-123456"))
2918 );
2919 assert_eq!(report.order_status, OrderStatus::Filled);
2920 assert_eq!(report.order_type, OrderType::Market);
2921 assert_eq!(report.time_in_force, TimeInForce::Ioc);
2922 assert_eq!(report.quantity, Quantity::from("100"));
2923 assert_eq!(report.filled_qty, Quantity::from("100"));
2924 assert_eq!(
2925 report.avg_px,
2926 Some(Decimal::from_str_exact("50006.0").unwrap())
2927 );
2928 }
2929
2930 #[rstest]
2931 fn test_synthesize_filled_order_status_report_requires_full_fill_size() {
2932 let order = make_order("O-123457");
2933 let cmd = make_cmd(Some("O-123457"), Some("KRAKEN-790"));
2934 let fills = vec![make_fill(
2935 "KRAKEN-790",
2936 Some("O-123457"),
2937 "40",
2938 "50000.0",
2939 1,
2940 )];
2941
2942 assert!(
2943 synthesize_filled_order_status_report(
2944 &Cache::default(),
2945 &QueriedOrder::new(&cmd, Some(&order)),
2946 &order,
2947 &fills
2948 )
2949 .is_none()
2950 );
2951 }
2952
2953 #[rstest]
2959 #[case::full_id_on_one_venue_order(&[("KRAKEN-791", false)], 0, Some("KRAKEN-791"))]
2960 #[case::shortened_id_on_one_venue_order(&[("KRAKEN-791", true)], 0, Some("KRAKEN-791"))]
2961 #[case::full_id_on_two_venue_orders(&[("KRAKEN-791", false), ("KRAKEN-792", false)], 0, None)]
2962 #[case::executed_before_the_order(&[("KRAKEN-791", true)], 10_000_000_000, None)]
2963 fn test_synthesize_filled_order_status_report_without_a_venue_order_id(
2964 #[case] fills: &[(&str, bool)],
2965 #[case] created_ns: u64,
2966 #[case] expected_venue_order_id: Option<&str>,
2967 ) {
2968 let long_client_order_id = "O-20260227-002321-004-001-1";
2969 let shortened = truncate_cl_ord_id(&ClientOrderId::from(long_client_order_id));
2970 let order = OrderTestBuilder::new(OrderType::Market)
2971 .instrument_id(InstrumentId::from(TEST_INSTRUMENT_ID))
2972 .client_order_id(ClientOrderId::from(long_client_order_id))
2973 .side(OrderSide::Buy)
2974 .quantity(Quantity::from("100"))
2975 .time_in_force(TimeInForce::Ioc)
2976 .ts_init(UnixNanos::from(created_ns))
2977 .build();
2978 let cmd = make_cmd(Some(long_client_order_id), None);
2979 let quantity = format!("{}", 100 / fills.len());
2980 let fills: Vec<FillReport> = fills
2981 .iter()
2982 .enumerate()
2983 .map(|(i, (venue_order_id, shortened_echo))| {
2984 let echoed = if *shortened_echo {
2985 shortened.as_str()
2986 } else {
2987 long_client_order_id
2988 };
2989 make_fill(
2990 venue_order_id,
2991 Some(echoed),
2992 &quantity,
2993 "50000.0",
2994 i as u64 + 1,
2995 )
2996 })
2997 .collect();
2998
2999 let report = synthesize_filled_order_status_report(
3000 &Cache::default(),
3001 &QueriedOrder::new(&cmd, Some(&order)),
3002 &order,
3003 &fills,
3004 );
3005
3006 assert_eq!(
3007 report.as_ref().map(|report| report.venue_order_id),
3008 expected_venue_order_id.map(VenueOrderId::from)
3009 );
3010
3011 if let Some(report) = report {
3012 assert_eq!(
3013 report.client_order_id,
3014 Some(ClientOrderId::from(long_client_order_id))
3015 );
3016 assert_eq!(report.order_status, OrderStatus::Filled);
3017 }
3018 }
3019}