Skip to main content

nautilus_kraken/execution/
spot.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 Spot execution client implementation.
17
18use std::{
19    collections::{BTreeSet, HashSet},
20    future::Future,
21    sync::Arc,
22    time::{Duration, Instant},
23};
24
25use anyhow::Context;
26use async_trait::async_trait;
27use futures_util::StreamExt;
28use jiff::Timestamp;
29use nautilus_common::{
30    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::{
50        AccountType, OmsType, OrderSide, OrderType, PositionSide, TimeInForce, TrailingOffsetType,
51        TriggerType,
52    },
53    events::OrderEventAny,
54    identifiers::{
55        AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, Venue, VenueOrderId,
56    },
57    instruments::{Instrument, InstrumentAny},
58    orders::{Order, OrderAny},
59    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
60    types::{AccountBalance, MarginBalance, Price, Quantity},
61};
62use rust_decimal::Decimal;
63use tokio_util::sync::CancellationToken;
64use ustr::Ustr;
65
66use super::{
67    absent_unless_unread, cached_order_for_status_command, command_failure_from_cancel_error,
68    command_failure_from_modify_error, command_failure_from_spot_batch_error,
69    command_failure_from_spot_batch_item, command_failure_from_spot_cancel_error,
70    command_failure_from_submit_error, earliest_venue_time, status_command_label,
71};
72use crate::{
73    common::{
74        consts::{KRAKEN_SPOT_POST_ONLY_ERROR, KRAKEN_VENUE},
75        enums::{KrakenOrderSide, KrakenOrderType, KrakenSpotTrigger, KrakenTimeInForce},
76        order_params::{
77            build_add_order_params, build_amend_order_params, build_cancel_order_params,
78            compute_ws_time_in_force, format_expire_time,
79        },
80        parse::truncate_cl_ord_id,
81    },
82    config::KrakenExecutionClientConfig,
83    http::{
84        KrakenSpotCancelOrderBatchParams, KrakenSpotCancelOrderParamsBuilder, KrakenSpotHttpClient,
85        spot::client::KRAKEN_SPOT_DEFAULT_RATE_LIMIT_PER_SECOND,
86    },
87    websocket::{
88        dispatch::{
89            self, OrderIdentity, WsDispatchState,
90            spot_orders::{OrderRequestState, PendingOperation, PendingRequest},
91        },
92        spot_v2::{
93            client::KrakenSpotWebSocketClient,
94            messages::{
95                KrakenSpotWsMessage, KrakenWsBatchAddOrder, KrakenWsBatchAddParams,
96                KrakenWsTriggerParams,
97            },
98        },
99    },
100};
101
102/// Kraken Spot execution client.
103///
104/// Provides order management and account operations for Kraken Spot markets.
105#[allow(dead_code)]
106#[derive(Debug)]
107pub struct KrakenSpotExecutionClient {
108    core: ExecutionClientCore,
109    clock: &'static AtomicTime,
110    config: KrakenExecutionClientConfig,
111    emitter: ExecutionEventEmitter,
112    http: KrakenSpotHttpClient,
113    ws: KrakenSpotWebSocketClient,
114    cancellation_token: CancellationToken,
115    session_tasks: TaskGroup,
116    pending_tasks: TaskGroup,
117    instruments: Arc<AtomicMap<InstrumentId, InstrumentAny>>,
118    order_qty_cache: Arc<AtomicMap<String, Decimal>>,
119    truncated_id_map: Arc<AtomicMap<String, ClientOrderId>>,
120    ws_dispatch_state: Arc<WsDispatchState>,
121    order_request_state: Arc<OrderRequestState>,
122    order_event_rx: Option<tokio::sync::mpsc::UnboundedReceiver<OrderEventAny>>,
123}
124
125impl KrakenSpotExecutionClient {
126    /// Creates a new [`KrakenSpotExecutionClient`].
127    ///
128    /// # Errors
129    ///
130    /// Returns an error if configuration validation or client initialization fails.
131    pub fn new(
132        core: ExecutionClientCore,
133        config: KrakenExecutionClientConfig,
134    ) -> anyhow::Result<Self> {
135        config.validate()?;
136
137        let clock = get_atomic_clock_realtime();
138        let emitter = ExecutionEventEmitter::new(
139            clock,
140            core.trader_id,
141            core.account_id,
142            config.spot_account_type,
143            None,
144        );
145
146        let session_tasks = TaskGroup::new();
147        let cancellation_token = session_tasks.cancellation_token();
148        let pending_tasks = TaskGroup::new();
149        let pending_spawner = pending_tasks
150            .spawner()
151            .context("Kraken Spot execution task admission is closed")?;
152        let api_key = config.api_key.expose_secret().to_owned();
153        let api_secret = config.api_secret.expose_secret().to_owned();
154        let proxy_url = config
155            .proxy_url
156            .as_ref()
157            .map(|value| value.expose_secret().to_owned());
158
159        let http = KrakenSpotHttpClient::with_credentials(
160            api_key,
161            api_secret,
162            config.environment,
163            config.base_url.clone(),
164            config.timeout_secs,
165            Some(config.max_retries),
166            None,
167            None,
168            proxy_url.clone(),
169            config
170                .max_requests_per_second
171                .unwrap_or(KRAKEN_SPOT_DEFAULT_RATE_LIMIT_PER_SECOND),
172        )?;
173
174        let data_config = crate::config::KrakenDataClientConfig {
175            api_key: Some(config.api_key.clone()),
176            api_secret: Some(config.api_secret.clone()),
177            product_type: config.product_type,
178            environment: config.environment,
179            base_url: config.base_url.clone(),
180            ws_public_url: None,
181            ws_private_url: Some(config.ws_url()),
182            ws_l3_url: None,
183            validate_l3_checksum: true,
184            validate_l2_checksum: true,
185            proxy_url: config.proxy_url.clone(),
186            timeout_secs: config.timeout_secs,
187            heartbeat_interval_secs: config.heartbeat_interval_secs,
188            // The authenticated order-routing WS keeps its prior behavior (no
189            // idle timeout); issue #4255 concerns the public spot data WS.
190            ws_idle_timeout_ms: 0,
191            max_requests_per_second: config.max_requests_per_second,
192            transport_backend: config.transport_backend,
193        };
194
195        let ws =
196            KrakenSpotWebSocketClient::new(data_config, cancellation_token.clone(), proxy_url)?
197                .with_socket_control(SocketControl::new(
198                    core.client_id,
199                    Some(*KRAKEN_VENUE),
200                    "kraken-spot-user-streams",
201                ));
202
203        let ws_dispatch_state = Arc::new(WsDispatchState::new());
204        // Connect() swaps in a live cmd_tx; capture the shared handle so the
205        // dispatcher reads the current sender, not the dropped placeholder.
206        let cmd_tx_handle = ws.handler_command_handle();
207        let (order_event_tx, order_event_rx) = tokio::sync::mpsc::unbounded_channel();
208        let order_request_state = Arc::new(OrderRequestState::new(
209            cmd_tx_handle,
210            order_event_tx,
211            Arc::clone(&ws_dispatch_state),
212            ws.req_id_counter(),
213            Duration::from_secs(config.ws_request_timeout_secs),
214            core.trader_id,
215            core.account_id,
216            ws.auth_token_handle(),
217            pending_spawner,
218            clock,
219        ));
220
221        Ok(Self {
222            core,
223            clock,
224            config,
225            emitter,
226            http,
227            ws,
228            cancellation_token,
229            session_tasks,
230            pending_tasks,
231            instruments: Arc::new(AtomicMap::new()),
232            order_qty_cache: Arc::new(AtomicMap::new()),
233            truncated_id_map: Arc::new(AtomicMap::new()),
234            ws_dispatch_state,
235            order_request_state,
236            order_event_rx: Some(order_event_rx),
237        })
238    }
239
240    fn register_order_identity(&self, order: &OrderAny) {
241        // Quote-quantity orders submit a quote amount (e.g. 100 USD), but the
242        // venue reports fills in base units (e.g. 0.001 BTC). Registering the
243        // raw `order.quantity()` would make the cumulative-fill comparison in
244        // the fill-side dispatch mismatch base against quote, leaving the
245        // order "open" forever. These orders instead flow through the
246        // untracked path and the engine reconciles them from status reports.
247        if order.is_quote_quantity() {
248            return;
249        }
250        self.ws_dispatch_state.register_identity(
251            order.client_order_id(),
252            OrderIdentity {
253                strategy_id: order.strategy_id(),
254                instrument_id: order.instrument_id(),
255                order_side: order.order_side(),
256                order_type: order.order_type(),
257                quantity: order.quantity(),
258            },
259        );
260    }
261
262    /// Returns a reference to the clock.
263    #[must_use]
264    pub fn clock(&self) -> &'static AtomicTime {
265        self.clock
266    }
267
268    /// Returns a reference to the event emitter.
269    #[must_use]
270    pub fn emitter(&self) -> &ExecutionEventEmitter {
271        &self.emitter
272    }
273
274    fn spawn_task<F>(&self, description: &'static str, fut: F)
275    where
276        F: Future<Output = anyhow::Result<()>> + Send + 'static,
277    {
278        let future = async move {
279            if let Err(e) = fut.await {
280                log::warn!("{description} failed: {e:?}");
281            }
282        };
283
284        if let Err(e) = self.pending_tasks.spawn(future) {
285            log::warn!("Skipping Kraken Spot {description} after shutdown began: {e}");
286        }
287    }
288
289    async fn finish_tasks(&self) -> anyhow::Result<()> {
290        let (session_result, pending_result) = tokio::join!(
291            self.session_tasks
292                .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2)),
293            self.pending_tasks
294                .finish_shutdown(Duration::from_secs(2), Duration::from_secs(2)),
295        );
296        session_result.context("failed to finish Kraken Spot execution session tasks")?;
297        pending_result.context("failed to finish Kraken Spot execution command tasks")?;
298        Ok(())
299    }
300
301    async fn prepare_task_groups(&mut self) -> anyhow::Result<()> {
302        if !self.session_tasks.is_open() || !self.pending_tasks.is_open() {
303            self.session_tasks.begin_shutdown();
304            self.pending_tasks.begin_shutdown();
305            self.finish_tasks().await?;
306            self.session_tasks
307                .start_generation()
308                .context("failed to start Kraken Spot execution session task generation")?;
309            self.pending_tasks
310                .start_generation()
311                .context("failed to start Kraken Spot execution command task generation")?;
312            self.cancellation_token = self.session_tasks.cancellation_token();
313            let pending_spawner = self
314                .pending_tasks
315                .spawner()
316                .context("Kraken Spot execution task admission is closed")?;
317            self.order_request_state.reset_task_spawner(pending_spawner);
318        }
319        Ok(())
320    }
321
322    async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
323        self.http.cancel_all_requests();
324        self.pending_tasks.begin_shutdown();
325        self.order_request_state.clear();
326        let ws_result = self.ws.close().await;
327        self.session_tasks.begin_shutdown();
328        let tasks_result = self.finish_tasks().await;
329        self.core.set_disconnected();
330        tasks_result?;
331        Ok(ws_result?)
332    }
333
334    fn submit_single_order(
335        &self,
336        command: &SubmitOrder,
337        order: &OrderAny,
338        task_name: &'static str,
339        leverage: Option<u16>,
340    ) {
341        if order.is_closed() {
342            log::warn!(
343                "Cannot submit closed order: client_order_id={}",
344                order.client_order_id()
345            );
346            return;
347        }
348
349        let order_type = order.order_type();
350        let time_in_force = order.time_in_force();
351
352        if time_in_force == TimeInForce::Fok && order_type != OrderType::Limit {
353            self.emitter.emit_order_denied(
354                order,
355                "FOK time in force only supported for LIMIT orders on Kraken Spot",
356            );
357            return;
358        }
359
360        if matches!(
361            order_type,
362            OrderType::TrailingStopMarket | OrderType::TrailingStopLimit
363        ) && let Some(offset_type) = order.trailing_offset_type()
364            && offset_type != TrailingOffsetType::Price
365        {
366            self.emitter.emit_order_denied(
367                order,
368                &format!(
369                    "Kraken Spot only supports Price trailing offset type: received {offset_type:?}"
370                ),
371            );
372            return;
373        }
374
375        if order.is_reduce_only() && self.config.spot_account_type == AccountType::Cash {
376            self.emitter
377                .emit_order_denied(order, "reduce_only requires spot_account_type=Margin");
378            return;
379        }
380
381        let client_order_id = order.client_order_id();
382
383        log::debug!("OrderSubmitted: client_order_id={client_order_id}");
384        self.register_order_identity(order);
385        self.emitter.emit_order_submitted(order);
386
387        let kraken_cl_ord_id = truncate_cl_ord_id(&client_order_id);
388
389        if !order.is_quote_quantity() {
390            self.order_qty_cache
391                .insert(kraken_cl_ord_id.clone(), order.quantity().as_decimal());
392        }
393
394        if kraken_cl_ord_id != client_order_id.as_str() {
395            self.truncated_id_map
396                .insert(kraken_cl_ord_id, client_order_id);
397        }
398
399        // Quote-quantity orders submit a quote-currency amount but the venue echoes
400        // fills in base units. The WS dispatch identity is intentionally not
401        // registered for these (see register_order_identity), so a WS round-trip
402        // would never emit OrderAccepted to the strategy. Plus order.quantity()
403        // for quote-qty is a quote amount that would be wrongly sent as `order_qty`
404        // (base units) on the WS path. Force REST.
405        let use_ws_trade = resolve_use_ws_trade(command.params.as_ref(), self.config.use_ws_trade);
406        if use_ws_trade && self.ws.is_active() && !order.is_quote_quantity() {
407            match self.submit_via_ws(command, order, leverage) {
408                Ok(()) => return,
409                Err(e) => log::warn!("Kraken WS submit_order fallback to REST: {e}"),
410            }
411        }
412
413        self.submit_via_rest(order, task_name, leverage);
414    }
415
416    fn submit_via_rest(&self, order: &OrderAny, task_name: &'static str, leverage: Option<u16>) {
417        let account_id = self.core.account_id;
418        let client_order_id = order.client_order_id();
419        let strategy_id = order.strategy_id();
420        let instrument_id = order.instrument_id();
421        let order_side = order.order_side();
422        let order_type = order.order_type();
423        let quantity = order.quantity();
424        let time_in_force = order.time_in_force();
425        let expire_time = order.expire_time();
426        let price = order.price();
427        let trigger_price = order.trigger_price();
428        let trigger_type = order.trigger_type();
429        let trailing_offset = order.trailing_offset();
430        let limit_offset = order.limit_offset();
431        let is_reduce_only = order.is_reduce_only();
432        let is_post_only = order.is_post_only();
433        let is_quote_quantity = order.is_quote_quantity();
434        let display_qty = order.display_qty();
435
436        let http = self.http.clone();
437        let emitter = self.emitter.clone();
438        let clock = self.clock;
439        let dispatch_state = self.ws_dispatch_state.clone();
440        let spot_account_type = self.config.spot_account_type;
441
442        self.spawn_task(task_name, async move {
443            let result = http
444                .submit_order(
445                    account_id,
446                    instrument_id,
447                    client_order_id,
448                    order_side,
449                    order_type,
450                    quantity,
451                    time_in_force,
452                    expire_time,
453                    price,
454                    trigger_price,
455                    trigger_type,
456                    trailing_offset,
457                    limit_offset,
458                    is_reduce_only,
459                    is_post_only,
460                    is_quote_quantity,
461                    display_qty,
462                    leverage,
463                    spot_account_type,
464                )
465                .await;
466
467            match result {
468                Ok(_) => {}
469                Err(e) => match command_failure_from_submit_error(&e) {
470                    CommandFailure::Ambiguous(reason) => {
471                        log::warn!(
472                            "{task_name} outcome is ambiguous for client_order_id={client_order_id}: {reason}"
473                        );
474                    }
475                    CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason) => {
476                        let ts_event = clock.get_time_ns();
477                        let error_msg = format!("{task_name} error: {reason}");
478                        let due_post_only = error_msg.contains("POST_ONLY_REJECTED")
479                            || error_msg.contains(KRAKEN_SPOT_POST_ONLY_ERROR);
480                        dispatch_state.cleanup_terminal(&client_order_id);
481                        emitter.emit_order_rejected_event(
482                            strategy_id,
483                            instrument_id,
484                            client_order_id,
485                            &error_msg,
486                            ts_event,
487                            due_post_only,
488                        );
489                    }
490                },
491            }
492
493            Ok(())
494        });
495    }
496    fn submit_via_ws(
497        &self,
498        command: &SubmitOrder,
499        order: &OrderAny,
500        leverage: Option<u16>,
501    ) -> anyhow::Result<()> {
502        let token = self
503            .ws
504            .auth_token_blocking()
505            .ok_or_else(|| anyhow::anyhow!("missing WS auth token"))?;
506
507        let params = build_add_order_params(command, order, token, leverage)?;
508        let identity = PendingRequest {
509            operation: PendingOperation::Submit,
510            client_order_ids: vec![command.client_order_id],
511            venue_order_ids: vec![None],
512            ts_sent_ns: 0,
513            new_quantity: None,
514            new_price: None,
515            new_trigger_price: None,
516        };
517        self.order_request_state
518            .submit(params, identity, self.clock.get_time_ns().as_u64())?;
519        Ok(())
520    }
521
522    fn cancel_single_order(&self, cmd: &CancelOrder) {
523        let use_ws_trade = resolve_use_ws_trade(cmd.params.as_ref(), self.config.use_ws_trade);
524        if use_ws_trade && self.ws.is_active() {
525            match self.cancel_via_ws(cmd) {
526                Ok(()) => return,
527                Err(e) => log::warn!("Kraken WS cancel_order fallback to REST: {e}"),
528            }
529        }
530
531        self.cancel_via_rest(cmd);
532    }
533
534    fn cancel_via_rest(&self, cmd: &CancelOrder) {
535        let account_id = self.core.account_id;
536        let command_id = cmd.command_id;
537        let client_order_id = cmd.client_order_id;
538        let venue_order_id = cmd.venue_order_id;
539        let strategy_id = cmd.strategy_id;
540        let instrument_id = cmd.instrument_id;
541
542        log::debug!(
543            "Canceling order: venue_order_id={venue_order_id:?}, client_order_id={client_order_id}"
544        );
545
546        let http = self.http.clone();
547        let emitter = self.emitter.clone();
548        let clock = self.clock;
549
550        self.spawn_task("cancel_order", async move {
551            if let Err(failure) = cancel_order_for_spot(
552                &http,
553                account_id,
554                instrument_id,
555                Some(client_order_id),
556                venue_order_id,
557            )
558            .await
559            {
560                handle_cancel_failure(
561                    &emitter,
562                    clock,
563                    strategy_id,
564                    instrument_id,
565                    client_order_id,
566                    venue_order_id,
567                    failure,
568                    command_id,
569                );
570            }
571            Ok(())
572        });
573    }
574
575    fn cancel_via_ws(&self, cmd: &CancelOrder) -> anyhow::Result<()> {
576        let token = self
577            .ws
578            .auth_token_blocking()
579            .ok_or_else(|| anyhow::anyhow!("missing WS auth token"))?;
580
581        let params = build_cancel_order_params(cmd, token);
582        let identity = PendingRequest {
583            operation: PendingOperation::Cancel,
584            client_order_ids: vec![cmd.client_order_id],
585            venue_order_ids: vec![cmd.venue_order_id],
586            ts_sent_ns: 0,
587            new_quantity: None,
588            new_price: None,
589            new_trigger_price: None,
590        };
591        self.order_request_state
592            .cancel(params, identity, self.clock.get_time_ns().as_u64())?;
593        Ok(())
594    }
595
596    fn spawn_message_handler(&mut self) -> anyhow::Result<()> {
597        let stream = self.ws.stream().map_err(|e| anyhow::anyhow!("{e}"))?;
598        let emitter = self.emitter.clone();
599        let instruments = self.instruments.clone();
600        let order_qty_cache = self.order_qty_cache.clone();
601        let truncated_id_map = self.truncated_id_map.clone();
602        let dispatch_state = self.ws_dispatch_state.clone();
603        let order_request_state = self.order_request_state.clone();
604        let account_id = self.core.account_id;
605        let clock = self.clock;
606        let cancellation_token = self.cancellation_token.clone();
607
608        let future = async move {
609            tokio::pin!(stream);
610
611            loop {
612                tokio::select! {
613                    () = cancellation_token.cancelled() => {
614                        log::debug!("Spot execution message handler cancelled");
615                        break;
616                    }
617                    msg = stream.next() => {
618                        match msg {
619                            Some(ws_msg) => {
620                                Self::handle_ws_message(
621                                    ws_msg,
622                                    &emitter,
623                                    &dispatch_state,
624                                    &order_request_state,
625                                    &instruments,
626                                    &order_qty_cache,
627                                    &truncated_id_map,
628                                    account_id,
629                                    clock,
630                                );
631                            }
632                            None => {
633                                log::debug!("Spot execution WebSocket stream ended");
634                                break;
635                            }
636                        }
637                    }
638                }
639            }
640        };
641
642        self.session_tasks
643            .spawn(future)
644            .context("failed to register Kraken Spot execution stream task")?;
645
646        let event_rx = self.order_event_rx.take();
647
648        if let Some(mut event_rx) = event_rx {
649            let emitter = self.emitter.clone();
650            let cancellation_token = self.cancellation_token.clone();
651
652            let future = async move {
653                loop {
654                    tokio::select! {
655                        () = cancellation_token.cancelled() => {
656                            log::debug!("Spot execution order-event forwarder cancelled");
657                            break;
658                        }
659                        event = event_rx.recv() => {
660                            match event {
661                                Some(event) => emitter.send_order_event(event),
662                                None => {
663                                    log::debug!("Spot execution order-event channel closed");
664                                    break;
665                                }
666                            }
667                        }
668                    }
669                }
670            };
671            self.session_tasks
672                .spawn(future)
673                .context("failed to register Kraken Spot order event task")?;
674        }
675
676        Ok(())
677    }
678
679    fn modify_single_order(&self, cmd: &ModifyOrder) {
680        let use_ws_trade = resolve_use_ws_trade(cmd.params.as_ref(), self.config.use_ws_trade);
681        if use_ws_trade && self.ws.is_active() {
682            match self.amend_via_ws(cmd) {
683                Ok(()) => return,
684                Err(e) => log::warn!("Kraken WS amend_order fallback to REST: {e}"),
685            }
686        }
687
688        self.amend_via_rest(cmd);
689    }
690
691    fn amend_via_rest(&self, cmd: &ModifyOrder) {
692        let command_id = cmd.command_id;
693        let client_order_id = cmd.client_order_id;
694        let venue_order_id = cmd.venue_order_id;
695        let strategy_id = cmd.strategy_id;
696        let instrument_id = cmd.instrument_id;
697        let quantity = cmd.quantity;
698        let price = cmd.price;
699
700        log::debug!(
701            "Modifying order: venue_order_id={venue_order_id:?}, client_order_id={client_order_id}"
702        );
703
704        let http = self.http.clone();
705        let emitter = self.emitter.clone();
706        let clock = self.clock;
707
708        self.spawn_task("modify_order", async move {
709            match http
710                .modify_order(
711                    instrument_id,
712                    Some(client_order_id),
713                    venue_order_id,
714                    quantity,
715                    price,
716                    None,
717                )
718                .await
719            {
720                Ok(_) => {}
721                Err(e) => match command_failure_from_modify_error(&e) {
722                    CommandFailure::Ambiguous(reason) => {
723                        log::warn!(
724                            "modify_order outcome is ambiguous for client_order_id={client_order_id}: {reason}"
725                        );
726                    }
727                    CommandFailure::NotSent(reason) => {
728                        let ts_event = clock.get_time_ns();
729                        emitter.emit_order_modify_denied_event(
730                            strategy_id,
731                            instrument_id,
732                            client_order_id,
733                            venue_order_id,
734                            &format!("modify-order error: {reason}"),
735                            ts_event,
736                            Some(command_id),
737                        );
738                    }
739                    CommandFailure::VenueRejected(reason) => {
740                        let ts_event = clock.get_time_ns();
741                        emitter.emit_order_modify_rejected_event(
742                            strategy_id,
743                            instrument_id,
744                            client_order_id,
745                            venue_order_id,
746                            &format!("modify-order error: {reason}"),
747                            ts_event,
748                            Some(command_id),
749                        );
750                    }
751                },
752            }
753            Ok(())
754        });
755    }
756
757    fn amend_via_ws(&self, cmd: &ModifyOrder) -> anyhow::Result<()> {
758        let token = self
759            .ws
760            .auth_token_blocking()
761            .ok_or_else(|| anyhow::anyhow!("missing WS auth token"))?;
762
763        let params = build_amend_order_params(cmd, token);
764        let identity = PendingRequest {
765            operation: PendingOperation::Amend,
766            client_order_ids: vec![cmd.client_order_id],
767            venue_order_ids: vec![cmd.venue_order_id],
768            ts_sent_ns: 0,
769            new_quantity: cmd.quantity,
770            new_price: cmd.price,
771            new_trigger_price: cmd.trigger_price,
772        };
773        self.order_request_state
774            .amend(params, identity, self.clock.get_time_ns().as_u64())?;
775        Ok(())
776    }
777
778    /// Polls the cache until the account is registered or timeout is reached.
779    async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
780        let account_id = self.core.account_id;
781
782        if self.core.cache().account(&account_id).is_some() {
783            log::info!("Account {account_id} registered");
784            return Ok(());
785        }
786
787        let start = Instant::now();
788        let timeout = Duration::from_secs_f64(timeout_secs);
789        let interval = Duration::from_millis(10);
790
791        loop {
792            tokio::time::sleep(interval).await;
793
794            if self.core.cache().account(&account_id).is_some() {
795                log::info!("Account {account_id} registered");
796                return Ok(());
797            }
798
799            if start.elapsed() >= timeout {
800                anyhow::bail!(
801                    "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
802                );
803            }
804        }
805    }
806
807    /// Returns the instruments of this account's cached open LONG positions that the startup
808    /// wallet read may report as flat, sorted.
809    ///
810    /// Only instruments with bulk position coverage qualify. A covered instrument is withheld,
811    /// with a warning, when the engine cache lacks it, since the engine would stop startup on its
812    /// report, or when a SELL on it may have filled without the startup reports showing the fill.
813    fn wallet_flat_candidates(&self, order_reports: &[OrderStatusReport]) -> Vec<InstrumentId> {
814        let cache = self.core.cache();
815        let account_id = self.core.account_id;
816        let instrument_ids: BTreeSet<InstrumentId> = cache
817            .positions_open(
818                Some(&*KRAKEN_VENUE),
819                None,
820                None,
821                Some(&account_id),
822                Some(PositionSide::Long),
823            )
824            .iter()
825            .map(|position| position.instrument_id)
826            .collect();
827
828        let mut candidates = Vec::new();
829
830        for instrument_id in instrument_ids {
831            if !self.provides_bulk_position_coverage(instrument_id) {
832                continue;
833            }
834
835            if cache.instrument(&instrument_id).is_none() {
836                log::warn!(
837                    "Withholding flat position report for {instrument_id}: instrument not in cache"
838                );
839                continue;
840            }
841
842            // A SELL that is not terminal could fill before the Balance read
843            if let Some(report) = order_reports.iter().find(|report| {
844                report.instrument_id == instrument_id
845                    && report.order_side == Some(OrderSide::Sell)
846                    && !report.order_status.is_closed()
847            }) {
848                log::warn!(
849                    "Withholding flat position report for {instrument_id}: SELL order {} is not terminal",
850                    report.venue_order_id,
851                );
852                continue;
853            }
854
855            // A cached SELL the startup reports cannot place may have filled unseen
856            let open_sells = cache.orders_open(
857                Some(&*KRAKEN_VENUE),
858                Some(&instrument_id),
859                None,
860                Some(&account_id),
861                Some(OrderSide::Sell),
862            );
863            let inflight_sells = cache.orders_inflight(
864                Some(&*KRAKEN_VENUE),
865                Some(&instrument_id),
866                None,
867                Some(&account_id),
868                Some(OrderSide::Sell),
869            );
870
871            if let Some(order) = open_sells.iter().chain(&inflight_sells).find(|order| {
872                order.venue_order_id().is_none_or(|venue_order_id| {
873                    !order_reports
874                        .iter()
875                        .any(|report| report.venue_order_id == venue_order_id)
876                })
877            }) {
878                log::warn!(
879                    "Withholding flat position report for {instrument_id}: cached SELL order {} has no order report",
880                    order.client_order_id(),
881                );
882                continue;
883            }
884
885            candidates.push(instrument_id);
886        }
887
888        candidates
889    }
890
891    #[expect(clippy::too_many_arguments)]
892    fn handle_ws_message(
893        msg: KrakenSpotWsMessage,
894        emitter: &ExecutionEventEmitter,
895        dispatch_state: &Arc<WsDispatchState>,
896        order_request_state: &Arc<OrderRequestState>,
897        instruments: &Arc<AtomicMap<InstrumentId, InstrumentAny>>,
898        order_qty_cache: &Arc<AtomicMap<String, Decimal>>,
899        truncated_id_map: &Arc<AtomicMap<String, ClientOrderId>>,
900        account_id: AccountId,
901        clock: &'static AtomicTime,
902    ) {
903        match msg {
904            KrakenSpotWsMessage::Execution(executions) => {
905                let ts_init = clock.get_time_ns();
906
907                for exec in &executions {
908                    dispatch::spot::execution(
909                        exec,
910                        dispatch_state,
911                        emitter,
912                        instruments,
913                        truncated_id_map,
914                        order_qty_cache,
915                        account_id,
916                        ts_init,
917                    );
918                }
919            }
920            KrakenSpotWsMessage::OrderResponse(response) => {
921                let ts_event = clock.get_time_ns().as_u64();
922                order_request_state.handle_response(&response, ts_event);
923            }
924            KrakenSpotWsMessage::Reconnected => {
925                log::info!("Spot execution WebSocket reconnected");
926            }
927            KrakenSpotWsMessage::Ticker(_)
928            | KrakenSpotWsMessage::Trade(_)
929            | KrakenSpotWsMessage::Book { .. }
930            | KrakenSpotWsMessage::Ohlc(_)
931            | KrakenSpotWsMessage::L3Snapshot(_)
932            | KrakenSpotWsMessage::L3Update(_)
933            | KrakenSpotWsMessage::SubscriptionAck { .. } => {}
934        }
935    }
936
937    fn batch_add_via_rest(
938        &self,
939        order_tuples: Vec<BatchOrderTuple>,
940        order_meta: Vec<(StrategyId, InstrumentId, ClientOrderId)>,
941    ) {
942        let http = self.http.clone();
943        let emitter = self.emitter.clone();
944        let clock = self.clock;
945        let dispatch_state = self.ws_dispatch_state.clone();
946        let spot_account_type = self.config.spot_account_type;
947
948        self.spawn_task("submit_order_list", async move {
949            let results = http
950                .send_order_batches(order_tuples, spot_account_type)
951                .await;
952
953            for (result, (strategy_id, instrument_id, client_order_id)) in
954                results.into_iter().zip(&order_meta)
955            {
956                let outcome = match result {
957                    Ok(item) => command_failure_from_spot_batch_item(item),
958                    Err(e) => Err(command_failure_from_spot_batch_error(&e)),
959                };
960
961                match outcome {
962                    Ok(()) => {}
963                    Err(CommandFailure::Ambiguous(reason)) => {
964                        log::warn!(
965                            "submit_order_list outcome is ambiguous for client_order_id={client_order_id}: {reason}"
966                        );
967                    }
968                    Err(
969                        CommandFailure::NotSent(reason)
970                        | CommandFailure::VenueRejected(reason),
971                    ) => {
972                        let ts_event = clock.get_time_ns();
973                        let due_post_only = reason.contains("POST_ONLY_REJECTED")
974                            || reason.contains(KRAKEN_SPOT_POST_ONLY_ERROR);
975                        dispatch_state.cleanup_terminal(client_order_id);
976                        emitter.emit_order_rejected_event(
977                            *strategy_id,
978                            *instrument_id,
979                            *client_order_id,
980                            &format!("submit_order_list batch item rejected: {reason}"),
981                            ts_event,
982                            due_post_only,
983                        );
984                    }
985                }
986            }
987            Ok(())
988        });
989    }
990
991    fn batch_add_via_ws(&self, orders: &[OrderAny], leverage: Option<u16>) -> anyhow::Result<()> {
992        let token = self
993            .ws
994            .auth_token_blocking()
995            .ok_or_else(|| anyhow::anyhow!("missing WS auth token"))?;
996
997        let first = orders
998            .first()
999            .ok_or_else(|| anyhow::anyhow!("batch_add requires at least one order"))?;
1000        let symbol = first.instrument_id().symbol.inner().to_string();
1001
1002        let mut batch_orders = Vec::with_capacity(orders.len());
1003        let mut client_order_ids = Vec::with_capacity(orders.len());
1004        for order in orders {
1005            batch_orders.push(build_batch_order(order, leverage)?);
1006            client_order_ids.push(order.client_order_id());
1007        }
1008        let venue_order_ids = vec![None; orders.len()];
1009
1010        let params = KrakenWsBatchAddParams {
1011            symbol,
1012            orders: batch_orders,
1013            token,
1014        };
1015        let identity = PendingRequest {
1016            operation: PendingOperation::BatchAdd,
1017            client_order_ids,
1018            venue_order_ids,
1019            ts_sent_ns: 0,
1020            new_quantity: None,
1021            new_price: None,
1022            new_trigger_price: None,
1023        };
1024        self.order_request_state
1025            .batch_add(params, identity, self.clock.get_time_ns().as_u64())?;
1026        Ok(())
1027    }
1028}
1029
1030type BatchOrderTuple = (
1031    InstrumentId,
1032    ClientOrderId,
1033    OrderSide,
1034    OrderType,
1035    Quantity,
1036    TimeInForce,
1037    Option<UnixNanos>,
1038    Option<Price>,
1039    Option<Price>,
1040    Option<TriggerType>,
1041    Option<Decimal>,
1042    Option<Decimal>,
1043    bool,
1044    bool,
1045    bool,
1046    Option<Quantity>,
1047    Option<u16>,
1048);
1049
1050fn build_batch_order(
1051    order: &OrderAny,
1052    leverage: Option<u16>,
1053) -> anyhow::Result<KrakenWsBatchAddOrder> {
1054    let order_type = order.order_type();
1055    let side = match order.order_side() {
1056        OrderSide::Buy => KrakenOrderSide::Buy,
1057        OrderSide::Sell => KrakenOrderSide::Sell,
1058    };
1059
1060    if matches!(
1061        order_type,
1062        OrderType::TrailingStopMarket | OrderType::TrailingStopLimit
1063    ) {
1064        anyhow::bail!(
1065            "Trailing stop orders are not yet supported on the Kraken WS batch path; use REST",
1066        );
1067    }
1068
1069    if order.display_qty().is_some() {
1070        anyhow::bail!(
1071            "Iceberg (display_qty) orders are not supported on the Kraken WS batch path; use REST",
1072        );
1073    }
1074
1075    let kraken_order_type = match order_type {
1076        OrderType::Market => KrakenOrderType::Market,
1077        OrderType::Limit => KrakenOrderType::Limit,
1078        OrderType::StopMarket => KrakenOrderType::StopLoss,
1079        OrderType::StopLimit => KrakenOrderType::StopLossLimit,
1080        OrderType::MarketIfTouched => KrakenOrderType::TakeProfit,
1081        OrderType::LimitIfTouched => KrakenOrderType::TakeProfitLimit,
1082        ty => anyhow::bail!("Unsupported order type for Kraken WS batch: {ty:?}"),
1083    };
1084
1085    let is_limit_order = matches!(
1086        order_type,
1087        OrderType::Limit | OrderType::StopLimit | OrderType::LimitIfTouched
1088    );
1089
1090    if is_limit_order && order.price().is_none() {
1091        anyhow::bail!("limit_price is required for batch order type {order_type:?}");
1092    }
1093
1094    let ws_tif =
1095        compute_ws_time_in_force(is_limit_order, order.time_in_force(), order.expire_time())?;
1096    let expire_time = match (ws_tif, order.expire_time()) {
1097        (Some(KrakenTimeInForce::GoodTilDate), Some(ts)) => Some(format_expire_time(ts)),
1098        _ => None,
1099    };
1100
1101    let is_conditional = matches!(
1102        order_type,
1103        OrderType::StopMarket
1104            | OrderType::StopLimit
1105            | OrderType::MarketIfTouched
1106            | OrderType::LimitIfTouched
1107    );
1108
1109    let trigger = if is_conditional {
1110        let trigger_ref = match order.trigger_type() {
1111            Some(TriggerType::IndexPrice) => KrakenSpotTrigger::Index,
1112            Some(TriggerType::LastPrice | TriggerType::Default) | None => KrakenSpotTrigger::Last,
1113            Some(other) => anyhow::bail!(
1114                "Unsupported trigger type for Kraken Spot WS batch: {other:?} (only LastPrice and IndexPrice supported)",
1115            ),
1116        };
1117        order.trigger_price().map(|tp| KrakenWsTriggerParams {
1118            reference: trigger_ref,
1119            price: tp.as_decimal(),
1120            price_type: None,
1121        })
1122    } else {
1123        None
1124    };
1125
1126    if is_conditional && trigger.is_none() {
1127        anyhow::bail!(
1128            "Conditional order type {order_type:?} requires trigger_price for Kraken WS batch",
1129        );
1130    }
1131
1132    Ok(KrakenWsBatchAddOrder {
1133        order_type: kraken_order_type,
1134        side,
1135        order_qty: order.quantity().as_decimal(),
1136        limit_price: order.price().map(|p| p.as_decimal()),
1137        cl_ord_id: Some(truncate_cl_ord_id(&order.client_order_id())),
1138        time_in_force: ws_tif,
1139        expire_time,
1140        post_only: order.is_post_only().then_some(true),
1141        reduce_only: order.is_reduce_only().then_some(true),
1142        leverage,
1143        trigger,
1144    })
1145}
1146
1147#[async_trait(?Send)]
1148impl ExecutionClient for KrakenSpotExecutionClient {
1149    fn is_connected(&self) -> bool {
1150        self.core.is_connected()
1151    }
1152
1153    fn client_id(&self) -> ClientId {
1154        self.core.client_id
1155    }
1156
1157    fn account_id(&self) -> AccountId {
1158        self.core.account_id
1159    }
1160
1161    fn venue(&self) -> Venue {
1162        *KRAKEN_VENUE
1163    }
1164
1165    fn oms_type(&self) -> OmsType {
1166        self.core.oms_type
1167    }
1168
1169    fn provides_bulk_position_coverage(&self, instrument_id: InstrumentId) -> bool {
1170        // Deferred to the HTTP client so the answer is derived from the read that produces the
1171        // reports, rather than restated here where it could drift.
1172        self.http.covers_bulk_position_reports(
1173            instrument_id,
1174            self.config.spot_account_type,
1175            self.config.use_spot_position_reports,
1176            Ustr::from(self.config.spot_positions_quote_currency.as_str()),
1177        )
1178    }
1179
1180    fn get_account(&self) -> Option<AccountAny> {
1181        self.core.cache().account_owned(&self.core.account_id)
1182    }
1183
1184    fn generate_account_state(
1185        &self,
1186        balances: Vec<AccountBalance>,
1187        margins: Vec<MarginBalance>,
1188        reported: bool,
1189        ts_event: UnixNanos,
1190        info: Option<Params>,
1191    ) -> anyhow::Result<()> {
1192        self.emitter
1193            .emit_account_state(balances, margins, reported, ts_event, info);
1194        Ok(())
1195    }
1196
1197    fn start(&mut self) -> anyhow::Result<()> {
1198        if self.core.is_started() {
1199            return Ok(());
1200        }
1201
1202        self.emitter.set_sender(get_exec_event_sender());
1203        self.core.set_started();
1204
1205        log::info!(
1206            "Started: client_id={}, account_id={}, product_type=Spot, environment={:?}",
1207            self.core.client_id,
1208            self.core.account_id,
1209            self.config.environment
1210        );
1211        Ok(())
1212    }
1213
1214    fn stop(&mut self) -> anyhow::Result<()> {
1215        if self.core.is_stopped() {
1216            return Ok(());
1217        }
1218
1219        self.http.cancel_all_requests();
1220        self.session_tasks.begin_shutdown();
1221        self.pending_tasks.begin_shutdown();
1222        self.ws.begin_shutdown();
1223        self.core.set_stopped();
1224        self.core.set_disconnected();
1225        log::info!("Stopped: client_id={}", self.core.client_id);
1226        Ok(())
1227    }
1228
1229    async fn connect(&mut self) -> anyhow::Result<()> {
1230        if self.core.is_connected() && self.session_tasks.is_open() && self.pending_tasks.is_open()
1231        {
1232            return Ok(());
1233        }
1234
1235        self.http.reset_cancellation_token();
1236        self.prepare_task_groups().await?;
1237
1238        if !self.core.instruments_initialized() {
1239            let instruments = self
1240                .http
1241                .request_instruments(None)
1242                .await
1243                .context("Failed to load Kraken spot instruments")?;
1244            log::debug!("Loaded {} Spot instruments", instruments.len());
1245            self.http.cache_instruments(&instruments);
1246            self.core.set_instruments_initialized();
1247        }
1248
1249        let session_result = async {
1250            self.ws
1251                .connect()
1252                .await
1253                .context("Failed to connect spot WebSocket")?;
1254            self.ws
1255                .wait_until_active(10.0)
1256                .await
1257                .context("Spot WebSocket failed to become active")?;
1258
1259            self.ws
1260                .authenticate()
1261                .await
1262                .context("Failed to authenticate spot WebSocket")?;
1263
1264            // Request initial account state and await registration before spawning
1265            // the message handler. Report events from execution snapshots conflict
1266            // with ExecEngine borrows during startup, so account registration must
1267            // complete first.
1268            let account_state = self
1269                .http
1270                .request_account_state(
1271                    self.core.account_id,
1272                    self.config.spot_account_type,
1273                    self.config.margin_balance_asset.as_deref(),
1274                )
1275                .await
1276                .context("Failed to request Kraken account state")?;
1277
1278            if !account_state.balances.is_empty() {
1279                log::debug!(
1280                    "Received account state with {} balance(s)",
1281                    account_state.balances.len()
1282                );
1283            }
1284
1285            self.emitter.send_account_state(account_state);
1286            self.await_account_registered(30.0).await?;
1287
1288            self.spawn_message_handler()?;
1289
1290            self.instruments.rcu(|m| {
1291                for instrument in self.http.instruments_cache.load().values() {
1292                    m.insert(instrument.id(), instrument.clone());
1293                }
1294            });
1295
1296            self.ws
1297                .subscribe_executions(false, false)
1298                .await
1299                .context("Failed to subscribe to executions")?;
1300
1301            log::debug!("Spot WebSocket authenticated and subscribed to executions");
1302
1303            Ok::<(), anyhow::Error>(())
1304        }
1305        .await;
1306
1307        if let Err(e) = session_result {
1308            if let Err(teardown_error) = self.teardown_partial_connect().await {
1309                return Err(e.context(format!(
1310                    "Kraken Spot execution startup teardown failed: {teardown_error}"
1311                )));
1312            }
1313            return Err(e);
1314        }
1315
1316        self.core.set_connected();
1317        log::info!("Connected: client_id={}", self.core.client_id);
1318        Ok(())
1319    }
1320
1321    async fn disconnect(&mut self) -> anyhow::Result<()> {
1322        self.teardown_partial_connect().await?;
1323        log::info!("Disconnected: client_id={}", self.core.client_id);
1324        Ok(())
1325    }
1326
1327    async fn generate_order_status_report(
1328        &self,
1329        cmd: &GenerateOrderStatusReport,
1330    ) -> anyhow::Result<Option<OrderStatusReport>> {
1331        log::debug!(
1332            "Generating order status report: venue_order_id={:?}, client_order_id={:?}",
1333            cmd.venue_order_id,
1334            cmd.client_order_id
1335        );
1336
1337        let account_id = self.core.account_id;
1338        // Scoped to the command's instrument, so an unresolvable open order on another pair is out
1339        // of scope for this lookup rather than failing it.
1340        let (reports, coverage) = self
1341            .http
1342            .request_order_status_reports_checked(account_id, cmd.instrument_id, None, None, false)
1343            .await?;
1344
1345        // Match by venue_order_id or client_order_id (comparing truncated form
1346        // since Kraken stores the truncated cl_ord_id for long IDs)
1347        let matched = reports.into_iter().find(|r| {
1348            cmd.venue_order_id
1349                .is_some_and(|id| r.venue_order_id.as_str() == id.as_str())
1350                || cmd.client_order_id.is_some_and(|id| {
1351                    r.client_order_id
1352                        .as_ref()
1353                        .is_some_and(|r_id| r_id.as_str() == truncate_cl_ord_id(&id))
1354                })
1355        });
1356
1357        if matched.is_some() {
1358            return Ok(matched);
1359        }
1360
1361        // Absence answers that the venue has no such order, so it needs a read that rules the
1362        // order out; otherwise reconciliation defers.
1363        let cached = cached_order_for_status_command(&self.core.cache(), cmd);
1364        let venue_order_id = cmd
1365            .venue_order_id
1366            .or_else(|| cached.as_ref().and_then(|order| order.venue_order_id()));
1367
1368        absent_unless_unread(
1369            &coverage,
1370            venue_order_id,
1371            cached.as_ref().map(earliest_venue_time),
1372            &status_command_label(cmd, venue_order_id),
1373        )
1374    }
1375
1376    async fn generate_order_status_reports(
1377        &self,
1378        cmd: &GenerateOrderStatusReports,
1379    ) -> anyhow::Result<Vec<OrderStatusReport>> {
1380        log::debug!(
1381            "Generating order status reports: instrument_id={:?}, open_only={}",
1382            cmd.instrument_id,
1383            cmd.open_only
1384        );
1385
1386        let account_id = self.core.account_id;
1387        let start = cmd.start.map(Timestamp::from);
1388        let end = cmd.end.map(Timestamp::from);
1389        self.http
1390            .request_order_status_reports(account_id, cmd.instrument_id, start, end, cmd.open_only)
1391            .await
1392    }
1393
1394    async fn generate_fill_reports(
1395        &self,
1396        cmd: GenerateFillReports,
1397    ) -> anyhow::Result<Vec<FillReport>> {
1398        log::debug!(
1399            "Generating fill reports: instrument_id={:?}",
1400            cmd.instrument_id
1401        );
1402
1403        let account_id = self.core.account_id;
1404        let start = cmd.start.map(Timestamp::from);
1405        let end = cmd.end.map(Timestamp::from);
1406        self.http
1407            .request_fill_reports(account_id, cmd.instrument_id, start, end)
1408            .await
1409    }
1410
1411    async fn generate_position_status_reports(
1412        &self,
1413        cmd: &GeneratePositionStatusReports,
1414    ) -> anyhow::Result<Vec<PositionStatusReport>> {
1415        log::debug!(
1416            "Generating position status reports: instrument_id={:?}",
1417            cmd.instrument_id
1418        );
1419
1420        let account_id = self.core.account_id;
1421        self.http
1422            .request_position_status_reports(
1423                account_id,
1424                cmd.instrument_id,
1425                self.config.spot_account_type,
1426                self.config.use_spot_position_reports,
1427                Ustr::from(self.config.spot_positions_quote_currency.as_str()),
1428            )
1429            .await
1430    }
1431
1432    async fn generate_mass_status(
1433        &self,
1434        lookback_mins: Option<u64>,
1435    ) -> anyhow::Result<Option<ExecutionMassStatus>> {
1436        log::debug!("Generating mass status: lookback_mins={lookback_mins:?}");
1437
1438        let ts_init = self.clock.get_time_ns();
1439        // Saturating arithmetic: an unclamped lookback must not overflow, and a cutoff before the
1440        // epoch must not panic converting into `UnixNanos`.
1441        let lookback_start = lookback_mins.map(|mins| {
1442            let nanos = mins.saturating_mul(60).saturating_mul(1_000_000_000);
1443            ts_init.saturating_sub(DurationNanos::new(nanos))
1444        });
1445        let start = lookback_start.map(Timestamp::from);
1446
1447        let account_id = self.core.account_id;
1448        // Read closed orders as well as open ones, matching the shared default. An order that
1449        // reached a terminal state while the node was down is only visible through ClosedOrders.
1450        // The lookback cutoff and the closed-order page cap bound the read.
1451        let (order_reports, orders_coverage) = self
1452            .http
1453            .request_order_status_reports_checked(account_id, None, start, None, false)
1454            .await?;
1455        let orders_complete = orders_coverage.is_complete();
1456        let (fill_reports, fills_complete) = self
1457            .http
1458            .request_fill_reports_checked(account_id, None, start, None)
1459            .await?;
1460        let quote_currency = Ustr::from(self.config.spot_positions_quote_currency.as_str());
1461        let position_reports = if self.config.spot_account_type != AccountType::Margin
1462            && self.config.use_spot_position_reports
1463        {
1464            let flat_candidates = self.wallet_flat_candidates(&order_reports);
1465            self.http
1466                .request_wallet_position_reports_with_flats(
1467                    account_id,
1468                    quote_currency,
1469                    &flat_candidates,
1470                )
1471                .await?
1472        } else {
1473            self.http
1474                .request_position_status_reports(
1475                    account_id,
1476                    None,
1477                    self.config.spot_account_type,
1478                    self.config.use_spot_position_reports,
1479                    quote_currency,
1480                )
1481                .await?
1482        };
1483
1484        let mut mass_status = ExecutionMassStatus::new(
1485            self.core.client_id,
1486            self.core.account_id,
1487            *KRAKEN_VENUE,
1488            ts_init,
1489            None,
1490        );
1491        mass_status.add_order_reports(order_reports);
1492        mass_status.add_fill_reports(fill_reports);
1493        mass_status.add_position_reports(position_reports);
1494        // One cutoff covers every historical query above, so record it with the completeness of
1495        // the sources the engine needs to interpret the bounded set.
1496        mass_status.set_report_window(lookback_start, orders_complete && fills_complete);
1497
1498        Ok(Some(mass_status))
1499    }
1500
1501    fn query_account(&self, cmd: QueryAccount) -> anyhow::Result<()> {
1502        log::debug!("Querying account: {cmd}");
1503
1504        let account_id = self.core.account_id;
1505        let http = self.http.clone();
1506        let emitter = self.emitter.clone();
1507
1508        let spot_account_type = self.config.spot_account_type;
1509        let margin_balance_asset = self.config.margin_balance_asset.clone();
1510        self.spawn_task("query_account", async move {
1511            let account_state = http
1512                .request_account_state(
1513                    account_id,
1514                    spot_account_type,
1515                    margin_balance_asset.as_deref(),
1516                )
1517                .await?;
1518            emitter.emit_account_state(
1519                account_state.balances.clone(),
1520                account_state.margins.clone(),
1521                account_state.is_reported,
1522                account_state.ts_event,
1523                account_state.info,
1524            );
1525            Ok(())
1526        });
1527
1528        Ok(())
1529    }
1530
1531    fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
1532        log::debug!("Querying order: {cmd}");
1533
1534        let venue_order_id = cmd
1535            .venue_order_id
1536            .context("venue_order_id required for query_order")?;
1537        let account_id = self.core.account_id;
1538        let instrument_id = cmd.instrument_id;
1539        let http = self.http.clone();
1540        let emitter = self.emitter.clone();
1541
1542        self.spawn_task("query_order", async move {
1543            // Scoped to the queried instrument, so an unresolvable open order on another pair is
1544            // out of scope for this lookup rather than failing it.
1545            let reports = http
1546                .request_order_status_reports(account_id, Some(instrument_id), None, None, true)
1547                .await
1548                .context("Failed to query order")?;
1549
1550            match reports
1551                .into_iter()
1552                .find(|r| r.venue_order_id == venue_order_id)
1553            {
1554                Some(report) => emitter.send_order_status_report(report),
1555                None => log::warn!(
1556                    "No open order {venue_order_id} found for {instrument_id}; no report emitted"
1557                ),
1558            }
1559            Ok(())
1560        });
1561
1562        Ok(())
1563    }
1564
1565    fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
1566        let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
1567        let leverage = match resolve_leverage(cmd.params.as_ref(), self.config.default_leverage) {
1568            Ok(lev) => lev,
1569            Err(reason) => {
1570                self.emitter.emit_order_denied(&order, &reason);
1571                return Ok(());
1572            }
1573        };
1574        self.submit_single_order(&cmd, &order, "submit_order", leverage);
1575        Ok(())
1576    }
1577
1578    fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1579        let orders = self.core.get_orders_for_list(&cmd.order_list)?;
1580
1581        log::debug!(
1582            "Submitting order list: order_list_id={}, count={}",
1583            cmd.order_list.id,
1584            orders.len()
1585        );
1586
1587        let leverage = match resolve_leverage(cmd.params.as_ref(), self.config.default_leverage) {
1588            Ok(lev) => lev,
1589            Err(reason) => {
1590                for order in &orders {
1591                    self.emitter.emit_order_denied(order, &reason);
1592                }
1593                return Ok(());
1594            }
1595        };
1596
1597        let mut order_tuples = Vec::with_capacity(orders.len());
1598        let mut order_meta = Vec::with_capacity(orders.len());
1599        let mut prepared_orders = Vec::with_capacity(orders.len());
1600
1601        for order in &orders {
1602            if order.is_closed() {
1603                log::warn!(
1604                    "Cannot submit closed order: client_order_id={}",
1605                    order.client_order_id()
1606                );
1607                continue;
1608            }
1609
1610            if order.time_in_force() == TimeInForce::Fok && order.order_type() != OrderType::Limit {
1611                self.emitter.emit_order_denied(
1612                    order,
1613                    "FOK time in force only supported for LIMIT orders on Kraken Spot",
1614                );
1615                continue;
1616            }
1617
1618            if matches!(
1619                order.order_type(),
1620                OrderType::TrailingStopMarket | OrderType::TrailingStopLimit
1621            ) && let Some(offset_type) = order.trailing_offset_type()
1622                && offset_type != TrailingOffsetType::Price
1623            {
1624                self.emitter.emit_order_denied(
1625                    order,
1626                    &format!(
1627                        "Kraken Spot only supports Price trailing offset type: received {offset_type:?}"
1628                    ),
1629                );
1630                continue;
1631            }
1632
1633            if order.is_reduce_only() && self.config.spot_account_type == AccountType::Cash {
1634                self.emitter
1635                    .emit_order_denied(order, "reduce_only requires spot_account_type=Margin");
1636                continue;
1637            }
1638
1639            let client_order_id = order.client_order_id();
1640            let kraken_cl_ord_id = truncate_cl_ord_id(&client_order_id);
1641
1642            self.register_order_identity(order);
1643            self.emitter.emit_order_submitted(order);
1644
1645            if !order.is_quote_quantity() {
1646                self.order_qty_cache
1647                    .insert(kraken_cl_ord_id.clone(), order.quantity().as_decimal());
1648            }
1649
1650            if kraken_cl_ord_id != client_order_id.as_str() {
1651                self.truncated_id_map
1652                    .insert(kraken_cl_ord_id, client_order_id);
1653            }
1654            order_tuples.push((
1655                order.instrument_id(),
1656                client_order_id,
1657                order.order_side(),
1658                order.order_type(),
1659                order.quantity(),
1660                order.time_in_force(),
1661                order.expire_time(),
1662                order.price(),
1663                order.trigger_price(),
1664                order.trigger_type(),
1665                order.trailing_offset(),
1666                order.limit_offset(),
1667                order.is_reduce_only(),
1668                order.is_post_only(),
1669                order.is_quote_quantity(),
1670                order.display_qty(),
1671                leverage,
1672            ));
1673
1674            order_meta.push((order.strategy_id(), order.instrument_id(), client_order_id));
1675            prepared_orders.push(order.clone());
1676        }
1677
1678        if order_tuples.is_empty() {
1679            return Ok(());
1680        }
1681
1682        let use_ws_trade = resolve_use_ws_trade(cmd.params.as_ref(), self.config.use_ws_trade);
1683        if use_ws_trade && self.ws.is_active() {
1684            let any_quote_qty = prepared_orders.iter().any(|o| o.is_quote_quantity());
1685            let symbols_match = prepared_orders
1686                .windows(2)
1687                .all(|w| w[0].instrument_id() == w[1].instrument_id());
1688
1689            if any_quote_qty {
1690                log::debug!(
1691                    "Kraken WS batch_add does not support quote-quantity orders, falling back to REST for order_list_id={}",
1692                    cmd.order_list.id,
1693                );
1694            } else if symbols_match {
1695                match self.batch_add_via_ws(&prepared_orders, leverage) {
1696                    Ok(()) => return Ok(()),
1697                    Err(e) => log::warn!("Kraken WS batch_add fallback to REST: {e}"),
1698                }
1699            } else {
1700                log::debug!(
1701                    "Kraken WS batch_add requires single shared symbol, falling back to REST for order_list_id={}",
1702                    cmd.order_list.id,
1703                );
1704            }
1705        }
1706
1707        self.batch_add_via_rest(order_tuples, order_meta);
1708
1709        Ok(())
1710    }
1711
1712    fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
1713        self.modify_single_order(&cmd);
1714        Ok(())
1715    }
1716
1717    fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1718        self.cancel_single_order(&cmd);
1719        Ok(())
1720    }
1721
1722    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
1723        let instrument_id = cmd.instrument_id;
1724
1725        log::debug!(
1726            "Canceling all orders: instrument_id={instrument_id}, side={:?}",
1727            cmd.order_side
1728        );
1729
1730        // Kraken's account-wide `CancelAll` ignores the requested instrument, so select the
1731        // matching open orders and cancel them by explicit venue id instead.
1732        let cancels: Vec<CancelOrder> = {
1733            let cache = self.core.cache();
1734            let ts_init = self.clock.get_time_ns();
1735            let correlation_id = cmd.correlation_id.or(Some(cmd.command_id));
1736
1737            // In-flight orders are included because the venue can have accepted an order the
1738            // cache still records as `Submitted`. The venue-wide cancellation this replaced
1739            // reached those, so selecting only open orders would silently stop covering them.
1740            let mut seen = HashSet::new();
1741
1742            cache
1743                .orders_open(None, Some(&instrument_id), None, None, None)
1744                .into_iter()
1745                .chain(cache.orders_inflight(None, Some(&instrument_id), None, None, None))
1746                .filter(|order| cmd.order_side.is_none_or(|side| order.order_side() == side))
1747                .filter(|order| seen.insert(order.client_order_id()))
1748                .map(|order| {
1749                    CancelOrder::new(
1750                        cmd.trader_id,
1751                        cmd.client_id,
1752                        // Each cancel keeps the owning strategy of the order it targets.
1753                        order.strategy_id(),
1754                        order.instrument_id(),
1755                        order.client_order_id(),
1756                        order.venue_order_id(),
1757                        UUID4::new(),
1758                        ts_init,
1759                        cmd.params.clone(),
1760                        correlation_id,
1761                    )
1762                })
1763                .collect()
1764        };
1765
1766        if cancels.is_empty() {
1767            log::debug!("No open orders to cancel for {instrument_id}");
1768            return Ok(());
1769        }
1770
1771        let http = self.http.clone();
1772
1773        let emitter = self.emitter.clone();
1774        let clock = self.clock;
1775        self.spawn_task("cancel_all_orders", async move {
1776            batch_cancel_orders_for_spot(&http, &cancels, &emitter, clock).await;
1777            Ok(())
1778        });
1779
1780        Ok(())
1781    }
1782
1783    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
1784        log::debug!(
1785            "Batch canceling orders: instrument_id={}, count={}",
1786            cmd.instrument_id,
1787            cmd.cancels.len()
1788        );
1789
1790        let use_ws_trade = resolve_use_ws_trade(cmd.params.as_ref(), self.config.use_ws_trade);
1791        if use_ws_trade && self.ws.is_active() {
1792            for cancel in &cmd.cancels {
1793                self.cancel_single_order(cancel);
1794            }
1795
1796            return Ok(());
1797        }
1798
1799        let http = self.http.clone();
1800        let cancels = cmd.cancels;
1801
1802        let emitter = self.emitter.clone();
1803        let clock = self.clock;
1804        self.spawn_task("batch_cancel_orders", async move {
1805            batch_cancel_orders_for_spot(&http, &cancels, &emitter, clock).await;
1806            Ok(())
1807        });
1808
1809        Ok(())
1810    }
1811}
1812
1813async fn cancel_order_for_spot(
1814    http: &KrakenSpotHttpClient,
1815    _account_id: AccountId,
1816    instrument_id: InstrumentId,
1817    client_order_id: Option<ClientOrderId>,
1818    venue_order_id: Option<VenueOrderId>,
1819) -> Result<(), CommandFailure> {
1820    http.get_cached_instrument(&instrument_id.symbol.inner())
1821        .ok_or_else(|| {
1822            CommandFailure::not_sent(InstrumentLookupError::not_found(instrument_id).to_string())
1823        })?;
1824
1825    let txid = venue_order_id.as_ref().map(ToString::to_string);
1826    let cl_ord_id = client_order_id.as_ref().map(truncate_cl_ord_id);
1827
1828    if txid.is_none() && cl_ord_id.is_none() {
1829        return Err(CommandFailure::not_sent(
1830            "Either client_order_id or venue_order_id must be provided",
1831        ));
1832    }
1833
1834    let mut builder = KrakenSpotCancelOrderParamsBuilder::default();
1835
1836    if let Some(ref id) = txid {
1837        builder.txid(id.clone());
1838    } else if let Some(ref id) = cl_ord_id {
1839        builder.cl_ord_id(id.clone());
1840    }
1841
1842    let params = builder
1843        .build()
1844        .map_err(|e| CommandFailure::not_sent(format!("Failed to build cancel params: {e}")))?;
1845
1846    http.inner
1847        .cancel_order(&params)
1848        .await
1849        .map_err(command_failure_from_spot_cancel_error)?;
1850
1851    Ok(())
1852}
1853
1854/// How Kraken identifies one order in a batch cancellation.
1855///
1856/// Kraken keys transaction IDs and client order IDs in separate request fields, so the two cannot
1857/// be mixed into one array.
1858enum SpotBatchCancelId {
1859    VenueOrderId(String),
1860    ClientOrderId(String),
1861}
1862
1863const SPOT_BATCH_CANCEL_LIMIT: usize = 50;
1864
1865async fn batch_cancel_orders_for_spot(
1866    http: &KrakenSpotHttpClient,
1867    cancels: &[CancelOrder],
1868    emitter: &ExecutionEventEmitter,
1869    clock: &AtomicTime,
1870) {
1871    let mut ids = Vec::new();
1872
1873    for cancel in cancels {
1874        match batch_cancel_item_for_spot(http, cancel) {
1875            Ok(id) => ids.push((id, cancel)),
1876            Err(CommandFailure::NotSent(reason)) => {
1877                emitter.emit_order_cancel_denied_event(
1878                    cancel.strategy_id,
1879                    cancel.instrument_id,
1880                    cancel.client_order_id,
1881                    cancel.venue_order_id,
1882                    &reason,
1883                    clock.get_time_ns(),
1884                    Some(cancel.command_id),
1885                );
1886            }
1887            Err(CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason)) => {
1888                log::warn!(
1889                    "Batch cancel command ambiguous failure for {}, awaiting reconciliation: {reason}",
1890                    cancel.client_order_id
1891                );
1892            }
1893        }
1894    }
1895
1896    // The venue limit counts both fields together, so chunk before splitting them.
1897    for chunk in ids.chunks(SPOT_BATCH_CANCEL_LIMIT) {
1898        let mut orders = Vec::new();
1899        let mut cl_ord_ids = Vec::new();
1900
1901        for (id, _) in chunk {
1902            match id {
1903                SpotBatchCancelId::VenueOrderId(venue_order_id) => {
1904                    orders.push(venue_order_id.clone());
1905                }
1906                SpotBatchCancelId::ClientOrderId(client_order_id) => {
1907                    cl_ord_ids.push(client_order_id.clone());
1908                }
1909            }
1910        }
1911
1912        let params = KrakenSpotCancelOrderBatchParams { orders, cl_ord_ids };
1913
1914        match http.inner.cancel_order_batch(&params).await {
1915            Ok(response) => {
1916                if response.count < chunk.len() as i32 {
1917                    log::warn!(
1918                        "Batch cancel accepted {} of {} request(s) without per-order results; awaiting reconciliation",
1919                        response.count,
1920                        chunk.len()
1921                    );
1922                }
1923            }
1924            Err(e) => handle_batch_cancel_failure(
1925                command_failure_from_cancel_error(e),
1926                chunk,
1927                emitter,
1928                clock,
1929            ),
1930        }
1931    }
1932}
1933
1934fn handle_batch_cancel_failure(
1935    failure: CommandFailure,
1936    chunk: &[(SpotBatchCancelId, &CancelOrder)],
1937    emitter: &ExecutionEventEmitter,
1938    clock: &AtomicTime,
1939) {
1940    match failure {
1941        CommandFailure::NotSent(reason) => {
1942            for (_, cancel) in chunk {
1943                emitter.emit_order_cancel_denied_event(
1944                    cancel.strategy_id,
1945                    cancel.instrument_id,
1946                    cancel.client_order_id,
1947                    cancel.venue_order_id,
1948                    &reason,
1949                    clock.get_time_ns(),
1950                    Some(cancel.command_id),
1951                );
1952            }
1953        }
1954        CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason) => {
1955            log::warn!(
1956                "Batch cancel failed without per-order results, awaiting reconciliation: {reason}"
1957            );
1958        }
1959    }
1960}
1961
1962fn batch_cancel_item_for_spot(
1963    http: &KrakenSpotHttpClient,
1964    cancel: &CancelOrder,
1965) -> Result<SpotBatchCancelId, CommandFailure> {
1966    http.get_cached_instrument(&cancel.instrument_id.symbol.inner())
1967        .ok_or_else(|| {
1968            CommandFailure::not_sent(
1969                InstrumentLookupError::not_found(cancel.instrument_id).to_string(),
1970            )
1971        })?;
1972
1973    if let Some(venue_order_id) = cancel.venue_order_id {
1974        Ok(SpotBatchCancelId::VenueOrderId(venue_order_id.to_string()))
1975    } else {
1976        Ok(SpotBatchCancelId::ClientOrderId(truncate_cl_ord_id(
1977            &cancel.client_order_id,
1978        )))
1979    }
1980}
1981
1982#[expect(
1983    clippy::too_many_arguments,
1984    reason = "Failure emission retains order identity and command correlation"
1985)]
1986fn handle_cancel_failure(
1987    emitter: &ExecutionEventEmitter,
1988    clock: &'static AtomicTime,
1989    strategy_id: StrategyId,
1990    instrument_id: InstrumentId,
1991    client_order_id: ClientOrderId,
1992    venue_order_id: Option<VenueOrderId>,
1993    failure: CommandFailure,
1994    causation_id: UUID4,
1995) {
1996    match failure {
1997        CommandFailure::VenueRejected(reason) => {
1998            emitter.emit_order_cancel_rejected_event(
1999                strategy_id,
2000                instrument_id,
2001                client_order_id,
2002                venue_order_id,
2003                &reason,
2004                clock.get_time_ns(),
2005                Some(causation_id),
2006            );
2007        }
2008        CommandFailure::NotSent(reason) => {
2009            emitter.emit_order_cancel_denied_event(
2010                strategy_id,
2011                instrument_id,
2012                client_order_id,
2013                venue_order_id,
2014                &reason,
2015                clock.get_time_ns(),
2016                Some(causation_id),
2017            );
2018        }
2019        CommandFailure::Ambiguous(reason) => {
2020            log::warn!(
2021                "Ambiguous cancel failure for {client_order_id}, awaiting reconciliation: {reason}"
2022            );
2023        }
2024    }
2025}
2026
2027fn resolve_leverage(params: Option<&Params>, default: Option<u16>) -> Result<Option<u16>, String> {
2028    let Some(p) = params else {
2029        return Ok(default);
2030    };
2031    let Some(raw) = p.get("leverage") else {
2032        return Ok(default);
2033    };
2034    let n = raw.as_u64().ok_or_else(|| {
2035        format!("Invalid leverage param: expected unsigned integer, received {raw}")
2036    })?;
2037    let lev =
2038        u16::try_from(n).map_err(|_| format!("leverage {n} exceeds maximum ({})", u16::MAX))?;
2039    Ok(Some(lev))
2040}
2041
2042/// Resolves the per-call `params["use_ws_trade"]` override against the
2043/// configured default. Non-boolean values warn and fall back to the default.
2044fn resolve_use_ws_trade(params: Option<&Params>, default: bool) -> bool {
2045    let Some(p) = params else {
2046        return default;
2047    };
2048    let Some(raw) = p.get("use_ws_trade") else {
2049        return default;
2050    };
2051
2052    match raw.as_bool() {
2053        Some(b) => b,
2054        None => {
2055            log::warn!(
2056                "Invalid use_ws_trade param: expected boolean, received {raw}; using default {default}",
2057            );
2058            default
2059        }
2060    }
2061}
2062
2063#[cfg(test)]
2064mod tests {
2065    use std::{
2066        cell::RefCell,
2067        rc::Rc,
2068        sync::{
2069            Arc,
2070            atomic::{AtomicUsize, Ordering},
2071        },
2072    };
2073
2074    use axum::{Router, http::StatusCode, routing::post};
2075    use nautilus_common::{
2076        cache::{Cache, InstrumentLookupError},
2077        clock::VirtualClock,
2078        factories::ExecutionClientFactory,
2079        live::sender::EventSender,
2080        messages::{ExecutionEvent, execution::CancelOrder},
2081    };
2082    use nautilus_core::{Params, UUID4, UnixNanos, time::get_atomic_clock_realtime};
2083    use nautilus_live::ExecutionEventEmitter;
2084    use nautilus_model::{
2085        identifiers::{
2086            AccountId, ClientOrderId, InstrumentId, StrategyId, Symbol, TraderId, VenueOrderId,
2087        },
2088        instruments::{CurrencyPair, InstrumentAny},
2089        types::{Currency, Price, Quantity},
2090    };
2091    use rstest::rstest;
2092    use serde_json::json;
2093
2094    use super::{
2095        AccountType, ClientId, CommandFailure, ExecutionClientCore, KrakenSpotExecutionClient,
2096        OmsType, batch_cancel_item_for_spot, cancel_order_for_spot, handle_cancel_failure,
2097        resolve_leverage, resolve_use_ws_trade,
2098    };
2099    use crate::{
2100        common::{consts::KRAKEN_VENUE, enums::KrakenProductType},
2101        config::KrakenExecutionClientConfig,
2102        factories::KrakenExecutionClientFactory,
2103        http::{KrakenHttpError, KrakenSpotHttpClient},
2104    };
2105
2106    const TEST_INSTRUMENT_ID: &str = "BTC/USDT.KRAKEN";
2107
2108    /// The REST cancel fallback transmits exactly once with retries at their default, and its
2109    /// failure surfaces as one ambiguous attempt: a retransmitted cancel may act on the venue
2110    /// twice, and a rejection would misreport an order the venue may already have canceled.
2111    #[tokio::test]
2112    async fn test_spot_rest_cancel_sends_once_and_stays_ambiguous_with_retries_enabled() {
2113        let request_count = Arc::new(AtomicUsize::new(0));
2114        let handler_count = request_count.clone();
2115        let router = Router::new().route(
2116            "/0/private/CancelOrder",
2117            post(move || {
2118                let handler_count = handler_count.clone();
2119                async move {
2120                    handler_count.fetch_add(1, Ordering::Relaxed);
2121                    StatusCode::TOO_MANY_REQUESTS
2122                }
2123            }),
2124        );
2125        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
2126        let addr = listener.local_addr().unwrap();
2127        tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
2128
2129        let cache = Rc::new(RefCell::new(Cache::default()));
2130        let core = ExecutionClientCore::new(
2131            TraderId::from("TRADER-001"),
2132            ClientId::from("KRAKEN"),
2133            *KRAKEN_VENUE,
2134            OmsType::Netting,
2135            AccountId::from("KRAKEN-001"),
2136            AccountType::Cash,
2137            None,
2138            cache,
2139        );
2140        let config = KrakenExecutionClientConfig {
2141            api_key: "test-key".into(),
2142            api_secret: "c2VjcmV0".into(),
2143            base_url: Some(format!("http://{addr}")),
2144            ..Default::default()
2145        };
2146        let client = KrakenSpotExecutionClient::new(core, config).unwrap();
2147        cache_test_spot_instrument(&client.http);
2148
2149        let result = cancel_order_for_spot(
2150            &client.http,
2151            AccountId::from("KRAKEN-001"),
2152            InstrumentId::from(TEST_INSTRUMENT_ID),
2153            Some(ClientOrderId::from("C-001")),
2154            Some(VenueOrderId::from("V-001")),
2155        )
2156        .await;
2157
2158        match result {
2159            Err(CommandFailure::Ambiguous(reason)) => {
2160                assert!(
2161                    reason.contains("HTTP error 429"),
2162                    "unexpected reason: {reason}"
2163                );
2164            }
2165            _ => panic!("Expected ambiguous cancel failure"),
2166        }
2167
2168        assert_eq!(request_count.load(Ordering::Relaxed), 1);
2169    }
2170
2171    /// The execution config's retry budget reaches the spot HTTP client for authenticated
2172    /// reads: with `max_retries: 1` an always-failing token request is sent exactly twice.
2173    /// A broken wiring (client default of 3) would send four times; a send-once read would
2174    /// send once. This restores the config wiring coverage the deleted `max_retries: 0`
2175    /// test provided.
2176    #[tokio::test]
2177    async fn test_execution_config_max_retries_reaches_spot_http_reads() {
2178        let request_count = Arc::new(AtomicUsize::new(0));
2179        let handler_count = request_count.clone();
2180        let router = Router::new().route(
2181            "/0/private/GetWebSocketsToken",
2182            post(move || {
2183                let handler_count = handler_count.clone();
2184                async move {
2185                    handler_count.fetch_add(1, Ordering::Relaxed);
2186
2187                    StatusCode::TOO_MANY_REQUESTS
2188                }
2189            }),
2190        );
2191
2192        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
2193        let addr = listener.local_addr().unwrap();
2194        tokio::spawn(async move {
2195            axum::serve(listener, router).await.unwrap();
2196        });
2197
2198        let cache = Rc::new(RefCell::new(Cache::default()));
2199
2200        let core = ExecutionClientCore::new(
2201            TraderId::from("TRADER-001"),
2202            ClientId::from("KRAKEN"),
2203            *KRAKEN_VENUE,
2204            OmsType::Netting,
2205            AccountId::from("KRAKEN-001"),
2206            AccountType::Cash,
2207            None,
2208            cache,
2209        );
2210
2211        let config = KrakenExecutionClientConfig {
2212            api_key: "test-key".into(),
2213            api_secret: "c2VjcmV0".into(),
2214            base_url: Some(format!("http://{addr}")),
2215            max_retries: 1,
2216            ..Default::default()
2217        };
2218
2219        let client = KrakenSpotExecutionClient::new(core, config).unwrap();
2220
2221        let result = client.http.inner.get_websockets_token().await;
2222
2223        let error = result.expect_err("always-429 token request must fail");
2224        assert!(
2225            matches!(error, KrakenHttpError::NetworkError(ref message) if message.contains("HTTP error 429")),
2226            "unexpected error: {error:?}"
2227        );
2228        assert_eq!(request_count.load(Ordering::Relaxed), 2);
2229    }
2230
2231    /// An ambiguous cancel failure emits no rejection or denial: reconciliation, not an event,
2232    /// resolves an order the venue may already have acted on.
2233    #[rstest]
2234    fn test_ambiguous_cancel_failure_emits_no_rejection() {
2235        let clock = get_atomic_clock_realtime();
2236
2237        let mut emitter = ExecutionEventEmitter::new(
2238            clock,
2239            TraderId::from("TRADER-001"),
2240            AccountId::from("KRAKEN-001"),
2241            AccountType::Cash,
2242            None,
2243        );
2244        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2245        let sender: EventSender<ExecutionEvent> = tx.into();
2246        emitter.set_sender(sender);
2247
2248        handle_cancel_failure(
2249            &emitter,
2250            clock,
2251            StrategyId::from("S-001"),
2252            InstrumentId::from(TEST_INSTRUMENT_ID),
2253            ClientOrderId::from("C-001"),
2254            Some(VenueOrderId::from("V-001")),
2255            CommandFailure::Ambiguous("HTTP error 429: rate limited".to_string()),
2256            UUID4::new(),
2257        );
2258
2259        assert!(
2260            rx.try_recv().is_err(),
2261            "ambiguous failure must emit no event"
2262        );
2263
2264        // Control: a venue rejection does emit, so the absent event above is meaningful.
2265        handle_cancel_failure(
2266            &emitter,
2267            clock,
2268            StrategyId::from("S-001"),
2269            InstrumentId::from(TEST_INSTRUMENT_ID),
2270            ClientOrderId::from("C-001"),
2271            Some(VenueOrderId::from("V-001")),
2272            CommandFailure::VenueRejected("EOrder: Unknown order".to_string()),
2273            UUID4::new(),
2274        );
2275
2276        assert!(rx.try_recv().is_ok(), "venue rejection must emit an event");
2277    }
2278
2279    fn cache_test_spot_instrument(http: &KrakenSpotHttpClient) -> InstrumentId {
2280        let instrument_id = InstrumentId::from(TEST_INSTRUMENT_ID);
2281
2282        http.cache_instrument(InstrumentAny::CurrencyPair(
2283            CurrencyPair::builder()
2284                .instrument_id(instrument_id)
2285                .raw_symbol(Symbol::new("XBTUSDT"))
2286                .base_currency(Currency::BTC())
2287                .quote_currency(Currency::USDT())
2288                .price_precision(2)
2289                .size_precision(8)
2290                .price_increment(Price::from("0.01"))
2291                .size_increment(Quantity::from("0.00000001"))
2292                .ts_event(0.into())
2293                .ts_init(0.into())
2294                .build()
2295                .unwrap(),
2296        ));
2297
2298        instrument_id
2299    }
2300
2301    fn params_with(key: &str, val: serde_json::Value) -> Params {
2302        let mut map = indexmap::IndexMap::new();
2303        map.insert(key.to_owned(), val);
2304        Params::new(map)
2305    }
2306
2307    #[tokio::test]
2308    async fn test_cancel_order_for_spot_missing_cached_instrument_returns_canonical_error() {
2309        let http = KrakenSpotHttpClient::default();
2310        let instrument_id = InstrumentId::from(TEST_INSTRUMENT_ID);
2311        let client_order_id = ClientOrderId::from("C-001");
2312        let venue_order_id = VenueOrderId::from("V-001");
2313
2314        let result = cancel_order_for_spot(
2315            &http,
2316            AccountId::from("KRAKEN-001"),
2317            instrument_id,
2318            Some(client_order_id),
2319            Some(venue_order_id),
2320        )
2321        .await;
2322
2323        match result {
2324            Err(CommandFailure::NotSent(reason)) => {
2325                assert_eq!(
2326                    reason,
2327                    InstrumentLookupError::not_found(instrument_id).to_string()
2328                );
2329            }
2330            _ => panic!("Expected local validation failure"),
2331        }
2332    }
2333
2334    #[rstest]
2335    fn test_batch_cancel_item_for_spot_missing_cached_instrument_returns_canonical_error() {
2336        let http = KrakenSpotHttpClient::default();
2337        let instrument_id = InstrumentId::from(TEST_INSTRUMENT_ID);
2338        let cancel = CancelOrder::new(
2339            TraderId::from("TESTER-001"),
2340            None,
2341            StrategyId::from("S-001"),
2342            instrument_id,
2343            ClientOrderId::from("C-001"),
2344            Some(VenueOrderId::from("V-001")),
2345            UUID4::new(),
2346            UnixNanos::default(),
2347            None,
2348            None,
2349        );
2350
2351        let result = batch_cancel_item_for_spot(&http, &cancel);
2352
2353        match result {
2354            Err(CommandFailure::NotSent(reason)) => {
2355                assert_eq!(
2356                    reason,
2357                    InstrumentLookupError::not_found(instrument_id).to_string()
2358                );
2359            }
2360            _ => panic!("Expected local validation failure"),
2361        }
2362    }
2363
2364    #[rstest]
2365    fn test_resolve_leverage_absent_uses_default() {
2366        let p = params_with("other", json!(1));
2367        assert_eq!(resolve_leverage(Some(&p), Some(3)).unwrap(), Some(3));
2368        assert_eq!(resolve_leverage(None, Some(5)).unwrap(), Some(5));
2369        assert_eq!(resolve_leverage(None, None).unwrap(), None);
2370    }
2371
2372    #[rstest]
2373    fn test_resolve_leverage_valid_integer() {
2374        let p = params_with("leverage", json!(5u64));
2375        assert_eq!(resolve_leverage(Some(&p), Some(3)).unwrap(), Some(5));
2376    }
2377
2378    #[rstest]
2379    fn test_resolve_leverage_string_value_errors() {
2380        let p = params_with("leverage", json!("5"));
2381        let err = resolve_leverage(Some(&p), Some(3)).unwrap_err();
2382        assert!(err.contains("Invalid leverage param"), "unexpected: {err}");
2383    }
2384
2385    #[rstest]
2386    fn test_resolve_leverage_overflow_errors() {
2387        let p = params_with("leverage", json!(65539u64));
2388        let err = resolve_leverage(Some(&p), None).unwrap_err();
2389        assert!(err.contains("exceeds maximum"), "unexpected: {err}");
2390    }
2391
2392    #[rstest]
2393    fn test_resolve_use_ws_trade_absent_uses_default() {
2394        let p = params_with("other", json!(1));
2395        assert!(resolve_use_ws_trade(Some(&p), true));
2396        assert!(!resolve_use_ws_trade(Some(&p), false));
2397        assert!(resolve_use_ws_trade(None, true));
2398        assert!(!resolve_use_ws_trade(None, false));
2399    }
2400
2401    #[rstest]
2402    fn test_resolve_use_ws_trade_overrides_default() {
2403        let p_false = params_with("use_ws_trade", json!(false));
2404        let p_true = params_with("use_ws_trade", json!(true));
2405        assert!(!resolve_use_ws_trade(Some(&p_false), true));
2406        assert!(resolve_use_ws_trade(Some(&p_true), false));
2407    }
2408
2409    #[rstest]
2410    fn test_resolve_use_ws_trade_non_boolean_falls_back_to_default() {
2411        let p = params_with("use_ws_trade", json!("true"));
2412        assert!(resolve_use_ws_trade(Some(&p), true));
2413        assert!(!resolve_use_ws_trade(Some(&p), false));
2414    }
2415
2416    #[rstest]
2417    fn test_execution_client_constructs_with_ws_trade_enabled() {
2418        let factory = KrakenExecutionClientFactory::new();
2419        let config = KrakenExecutionClientConfig {
2420            product_type: KrakenProductType::Spot,
2421            use_ws_trade: true,
2422            ws_request_timeout_secs: 7,
2423            ..Default::default()
2424        };
2425        let cache = Rc::new(RefCell::new(Cache::default()));
2426        let clock = Rc::new(RefCell::new(VirtualClock::new()));
2427
2428        let result = factory.create(
2429            TraderId::from("TRADER-001"),
2430            "KRAKEN-WS",
2431            &config,
2432            cache.into(),
2433            clock,
2434        );
2435        assert!(result.is_ok(), "construction failed: {:?}", result.err());
2436    }
2437}