1use 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#[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 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 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 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 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 #[must_use]
264 pub fn clock(&self) -> &'static AtomicTime {
265 self.clock
266 }
267
268 #[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 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 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 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 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 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 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 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 let (reports, coverage) = self
1341 .http
1342 .request_order_status_reports_checked(account_id, cmd.instrument_id, None, None, false)
1343 .await?;
1344
1345 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 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 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 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 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 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 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 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 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(¶ms)
1848 .await
1849 .map_err(command_failure_from_spot_cancel_error)?;
1850
1851 Ok(())
1852}
1853
1854enum 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 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(¶ms).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
2042fn 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 #[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 #[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 #[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 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}