Skip to main content

nautilus_kraken/execution/
futures.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Kraken Futures execution client implementation.
17
18use 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
92/// Maximum order IDs per `/orders/status` request for Kraken Futures API.
93const FUTURES_ORDERS_STATUS_LIMIT: usize = 50;
94
95/// Allowance for skew between the node's clock, which stamps an order's creation, and the venue's,
96/// which stamps its placement, kept short so an older order whose client order ID shortens alike
97/// stays withheld.
98const ORDERS_STATUS_CLOCK_SKEW: DurationNanos = DurationNanos::from_secs(5);
99
100/// Kraken Futures execution client.
101///
102/// Provides order management, account operations, and position management
103/// for Kraken Futures markets.
104#[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    /// Creates a new [`KrakenFuturesExecutionClient`].
126    ///
127    /// # Errors
128    ///
129    /// Returns an error if configuration validation or client initialization fails.
130    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    /// Returns a reference to the clock.
218    #[must_use]
219    pub fn clock(&self) -> &'static AtomicTime {
220        self.clock
221    }
222
223    /// Returns a reference to the event emitter.
224    #[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        // Scoped to the command's instrument, so an unresolvable open order on another contract
799        // is out of scope for this lookup rather than failing it.
800        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        // A withheld report answers for nothing, but it still shows which venue order echoes the
806        // queried client order ID.
807        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            // A terminal history match is priced from its fills; short of them the query fails so
822            // the engine defers, as the orders-status window does below. A failed fills read counts
823            // as an empty page, so a cached order holding every execution still prices it.
824            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        // Absence answers that the venue has no such order, so it needs a read that rules the
846        // order out; otherwise reconciliation defers.
847        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        // Held orders never appear on /openorders; query the 5-second window
864        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        // Window filled reports have no avg_px; price them from fills below
881        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            // Unpriced filled reports would close at the order price
907            (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        // A terminal history report with an executed quantity carries no price: it is priced from
947        // its fills, else withheld. A withheld cached order counts as missing and the engine
948        // resolves it through the single-order query, which prices it or defers; an uncached one
949        // stays withheld until its fills reach the fills page.
950        if reports.iter().any(is_unpriced_terminal_report) {
951            // A failed fills read counts as an empty page: a cached order holding every execution
952            // still prices its report, and only the reports nothing covers are withheld.
953            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            // The window carries no fill price, so a filled report would be inferred at the
995            // order price. A canceled one with executions passes, since reconciliation waits for
996            // its fills rather than infer them.
997            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        // Saturating arithmetic: an unclamped lookback must not overflow, and a cutoff before the
1077        // epoch must not panic converting into `UnixNanos`.
1078        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        // Read the order-event history as well as open orders, matching the shared default. An
1086        // order that reached a terminal state while the node was down is only visible there. The
1087        // venue can refuse the history page, since every `/history` endpoint draws on one token
1088        // pool; a refusal degrades startup to the open-only read and marks the set incomplete.
1089        // Any other failure fails the mass status, as a failed open-order read does.
1090        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        // Captured before the orders-status extension is merged in, so the safeguard below applies
1114        // to the venue read alone and leaves the extension to its own rule.
1115        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        // The window carries no fill price, so a filled report would be inferred at the order
1128        // price. A canceled one with executions passes, since reconciliation waits for its fills
1129        // rather than infer them. A withheld window report leaves the set incomplete. A venue-read
1130        // report that took a window state answers to these rules, not the venue read's.
1131        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        // A terminal history report with an executed quantity carries no price, so it is priced
1172        // from its fills as on the bulk path, which requires exact coverage. The adapter reads
1173        // only the latest fills page, so an execution older than that page is absent and does
1174        // not come back on a later read. Unpriced, reconciliation would infer the remainder at
1175        // the order's limit price, so such a report is withheld and the set marked incomplete.
1176        // A withheld report's page fills stay for a cached order, since the engine reconciles
1177        // priced fills against a cached order with no report. An uncached order's fills go with
1178        // its report. With no order, and no venue position ID on a Kraken fill, the engine drops
1179        // them, but on an instrument with a position report its partial-window adjustment first
1180        // counts every fill there when sizing a synthetic opening, so they would skew that
1181        // opening without ever being applied. The same goes for an order the read itself left
1182        // without a report because a skipped row names it, unless a fill echoes a cached order
1183        // the venue order ID does not index yet, which the engine applies it to.
1184        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        // Terminal history orders must not open a position on an instrument the venue reports
1256        // flat. The position read returns open positions only, so an instrument with no position
1257        // report is flat at the venue. With no lookback declared the engine applies every kept
1258        // fill to positions, and the fills read is a single page, so a round trip whose opening
1259        // fill is older than that page would leave its closing side alone and open a position
1260        // opposite to the one the venue closed. On a flat instrument the fills of every order on
1261        // the read pages that the cache does not hold are netted, open orders included, since an
1262        // open order's fill can offset a terminal one. When they do not net to zero and a terminal
1263        // order is among them, the terminal orders are withheld with their fills and the set is
1264        // marked incomplete; open orders stay, and an open order's own fill can still open a
1265        // position. With a bounded lookback the engine projects
1266        // terminal orders onto order state only, so this applies to the unbounded read alone.
1267        // Cached orders are left out, since their fills reconcile against the cached order and
1268        // its position.
1269        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        // As for spot: one cutoff for every historical query, recorded with its completeness.
1357        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        // The cached order the venue order ID indexes names the report, as on every other path
1391        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            // Scoped to the queried instrument, so an unresolvable open order on another contract
1399            // is out of scope for this lookup rather than failing it.
1400            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        // A list's open members go out together or not at all, so no leg is stranded
1441        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            // Kraken batch endpoint only supports limit and stop orders,
1465            // submit market orders individually
1466            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        // Side-filtered cancellation reuses the explicit-id batch path rather than sending one
1598        // HTTP cancel per order.
1599        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            // As for spot: the venue can have accepted an order the cache still records as
1605            // `Submitted`, so in-flight orders are selected alongside open ones.
1606            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                        // Each cancel keeps the owning strategy of the order it targets.
1619                        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    /// The client order ID an item without a venue order ID sends, which the venue echoes on its
1677    /// rejection.
1678    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    /// Returns `/orders/status` reports for cached-open orders the given
1985    /// venue reports do not cover, and whether it withheld any report.
1986    ///
1987    /// A Maker Protection hold never reaches the book, so it is invisible to
1988    /// an open-orders snapshot while the venue still knows the order within
1989    /// its 5-second `/orders/status` window. Orders without a venue order ID
1990    /// yet (their submit acknowledgement is still inside the hold window) are
1991    /// queried by their client order ID, in both forms `venue_client_order_ids`
1992    /// gives, the only venue handle that exists during the window. Each report
1993    /// is named by the cached order it describes, as
1994    /// `attribute_orders_status_reports` resolves it.
1995    ///
1996    /// # Errors
1997    ///
1998    /// Returns an error if the underlying request fails or the venue rejects
1999    /// it, so callers defer rather than treat the orders as missing.
2000    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                // Spot and Futures share the KRAKEN venue and one cache
2019                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        // A client order ID request returns every order holding the ID, so a run scoped to one
2085        // instrument keeps only that instrument's reports.
2086        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
2094/// Checks an order against the venue's documented limits before it is submitted.
2095fn 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
2110/// The cached order a report describes, found by its venue order ID.
2111fn 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
2116/// The order a single-order query asks about, and how a venue row is tied to it.
2117///
2118/// With its venue order ID known, the row carrying that ID is the order. Otherwise a row is the
2119/// order's when it echoes the order's client order ID in either form `venue_client_order_ids`
2120/// gives, on the order's instrument and side, placed no more than `ORDERS_STATUS_CLOCK_SKEW`
2121/// before the order's creation: an older row is another order whose ID shortens alike or that
2122/// reused the ID. A fill carries no placement time, so its fill time stands in, which rules out
2123/// only a fill executed before the order's creation. Without a cached order to check against, the
2124/// echo alone ties a row to it. A row of a venue order the cache indexes for another order is that
2125/// order's whatever it echoes, since another order's full ID can be this order's shortened one.
2126/// A row echoing the full ID of another cached order sent but carrying no venue order ID, on that
2127/// order's instrument and side and placed no more than `ORDERS_STATUS_CLOCK_SKEW` before its
2128/// creation, can be either order's while the cache indexes its venue order for neither, and leaves
2129/// the answer open.
2130struct 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    /// Whether a row echoing `echoed` on `instrument_id` and `side`, placed at `placed`, can be
2151    /// this order by its client order ID.
2152    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    /// Whether the cache indexes `venue_order_id` for an order other than this one.
2176    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    /// Whether another cached order, sent but without a venue order ID, holds `echoed` as its full
2205    /// client order ID and a row on `instrument_id` and `side`, placed at `placed`, can be that
2206    /// order's.
2207    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    /// The report of this order, named by its client order ID when matched by it.
2250    ///
2251    /// # Errors
2252    ///
2253    /// Returns an error if reports of several venue orders can be this order, or a report that can
2254    /// be this order can also be another cached order's by its full client order ID, so the query
2255    /// defers rather than take one of them.
2256    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    /// Whether a report of another venue order can be this order, which leaves absence open:
2301    /// the venue may hold the order under that report.
2302    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    /// Whether a fill other than one of this order's known venue order can be this order's, which
2311    /// leaves absence open. With the venue order ID unknown, any fill echoing the order counts: it
2312    /// may be this order's, short of its quantity or beside another venue order's.
2313    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
2320/// The client order IDs the venue can hold `client_order_id` under: the full ID the adapter sends
2321/// and, when it differs, the form `truncate_cl_ord_id` gives, which an adapter that shortened
2322/// futures IDs past 18 characters sent and which another order's ID can share.
2323fn 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/// An open order the orders-status window is asked about by its client order ID.
2331#[derive(Clone, Copy, Debug)]
2332struct HeldOrder {
2333    client_order_id: ClientOrderId,
2334    instrument_id: InstrumentId,
2335    side: OrderSide,
2336    ts_init: UnixNanos,
2337}
2338
2339/// Names each report by the cached order indexing its venue order ID. The venue echoes the client
2340/// order ID an order was sent with, which for an order sent with a shortened ID is not the cached
2341/// one, and reconciliation matches a report carrying a client order ID by that ID alone.
2342fn 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
2350/// Names each fill by the cached order indexing its venue order ID, as
2351/// [`name_reports_by_cached_order`] names order reports.
2352fn 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
2360/// Folds window reports into the venue read by venue order ID, returning the reports of the orders
2361/// the venue read did not return and the venue order IDs of the reports that took a window state.
2362///
2363/// A window copy of an order the venue read returned names that report by the cached order the
2364/// window attributed it to, then is dropped, so the order reaches reconciliation once with the
2365/// venue read's fields, such as time in force, post-only and trigger fields, which the window
2366/// lacks. When the report is open and the copy describes a later state, by `supersedes`, the
2367/// report takes the copy's status, quantities, price, average price, cancel reason and last
2368/// update, and answers to the window's rules; a closed report keeps its own state and the pricing
2369/// path it has.
2370fn 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(&copy.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(&copy, 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
2407/// Keeps one report per venue order ID, the one describing the order's latest state.
2408///
2409/// The venue-ID and client-order-ID requests run one after the other, so both can return one order
2410/// in different states. `supersedes` decides between them rather than the order the requests ran
2411/// in: a closed state over an open one, else the later venue update, else the larger filled
2412/// quantity.
2413fn 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
2429/// Names each `/orders/status` report by the client order ID of the cached order it describes,
2430/// returning the reports it attributes and whether it withheld any. `reports` holds one report per
2431/// venue order ID.
2432///
2433/// The venue echoes the client order ID an order was sent with, in either form
2434/// `venue_client_order_ids` gives, and reconciliation matches a report carrying a client order ID
2435/// by that ID alone. A report takes the ID of the cached order indexing its venue order ID.
2436/// Otherwise its echoed ID names an order queried by client order ID only when exactly one such
2437/// order holds it, exactly one report without an indexed venue order ID carries it, the report's
2438/// instrument and side are the order's, and the venue placed it no more than
2439/// `ORDERS_STATUS_CLOCK_SKEW` before the order's creation, which keeps out an older order whose ID
2440/// shortens alike or that reused the ID. Two reports that would name one order, one echoing each
2441/// form, name neither. Any other report is withheld with a warning naming the reason, since it
2442/// cannot be tied to exactly one cached order: reconciliation would take it for an external order
2443/// or for the wrong one.
2444fn attribute_orders_status_reports(
2445    cache: &Cache,
2446    queried_by_cli_ord_id: &[HeldOrder],
2447    reports: Vec<OrderStatusReport>,
2448) -> (Vec<OrderStatusReport>, bool) {
2449    // None marks an echoed ID that several queried orders share
2450    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    // A queried order echoed in full on one report and shortened on another is named by both
2517    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
2557/// Whether a combined order read failed because the venue refused its history page.
2558///
2559/// The rule goes by the response's shape: an error body under a success status, whatever its
2560/// code, or HTTP 429 is a refusal. Any other HTTP status, a transport failure and a body that
2561/// cannot be parsed are faults, as is any failure of the open-order read, which carries no typed
2562/// error. A credential failure fails that open-order read, which runs first with the same key.
2563fn 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
2574/// Whether `report` is terminal with an executed quantity it carries no price for.
2575///
2576/// An order history row has no average price. Unpriced, reconciliation infers the executed
2577/// quantity at the report's limit price, and cannot price a market order at all.
2578fn 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
2586/// Sets `report.avg_px` to the quantity-weighted price of the order's executions.
2587///
2588/// The venue's own fills price the report when they cover its filled quantity exactly. Otherwise
2589/// the fills a cached order has recorded complete the page, each counted once by trade ID, and
2590/// must cover it exactly too. Exact coverage rejects a double count: an execution the engine
2591/// inferred carries a synthetic trade ID, so it would otherwise be counted beside the venue fill
2592/// it stands for. The adapter reads only the latest fills page, so an older execution can be absent
2593/// from it.
2594///
2595/// # Errors
2596///
2597/// Returns an error if neither source covers the report's filled quantity exactly. The error
2598/// contains the covered quantity, and the report remains unpriced.
2599fn 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    // A fill of another venue order can carry the same client order ID, so with the venue order
2656    // ID known only its fills count, and without it the fills must belong to one venue order that
2657    // no other cached order can hold by its full client order ID.
2658    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    /// Without a venue order ID the fills must carry the order's client order ID, in full or in the
2954    /// shortened form the venue holds an order sent with one under, be executed no earlier than the
2955    /// clock skew allowance before the order's creation, and belong to one venue order. Fills of
2956    /// two venue orders sharing the ID, or executed earlier than that, prove nothing about this
2957    /// one.
2958    #[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}