1use std::{future::Future, io, time::Duration};
19
20use anyhow::Context;
21use async_trait::async_trait;
22use futures_util::{StreamExt, pin_mut};
23use nautilus_common::{
24 cache::InstrumentLookupError,
25 clients::{ExecutionClient, ExecutionReportTask},
26 live::runner::get_exec_event_sender,
27 messages::execution::{
28 BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
29 GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
30 ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
31 },
32};
33use nautilus_core::{
34 DurationNanos, Params, UnixNanos,
35 time::{AtomicTime, get_atomic_clock_realtime},
36};
37use nautilus_live::{
38 ExecutionClientCore, ExecutionEventEmitter, SocketControl,
39 task::{TaskGroup, TaskGroupGuard},
40};
41use nautilus_model::{
42 accounts::AccountAny,
43 enums::{AccountType, OmsType, OrderType, PositionSide, TimeInForce},
44 events::OrderEventAny,
45 identifiers::{AccountId, ClientId, ClientOrderId, InstrumentId, Venue, VenueOrderId},
46 instruments::InstrumentAny,
47 orders::{Order, OrderAny},
48 reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
49 types::{AccountBalance, MarginBalance, Quantity},
50};
51use serde::Serialize;
52
53use crate::{
54 common::{
55 capabilities::validate_order,
56 consts::{DERIBIT_VENUE, DERIBIT_WS_HEARTBEAT_SECS},
57 enums::resolve_trigger_type,
58 },
59 config::DeribitExecutionClientConfig,
60 http::{
61 client::DeribitHttpClient, error::DeribitHttpError, models::DeribitCurrency,
62 query::GetOrderStateParams, reconciliation::ReconciliationScope,
63 },
64 websocket::{
65 auth::DERIBIT_EXECUTION_SESSION_NAME,
66 client::DeribitWebSocketClient,
67 error::DeribitWsError,
68 failure::{REASON_NOT_STARTED, classify_deribit_command_failure, terminal_reason},
69 messages::{DeribitEditParams, DeribitOrderParams, NautilusWsMessage},
70 parse::parse_user_order_msg,
71 },
72};
73
74#[derive(Debug)]
76pub struct DeribitExecutionClient {
77 core: ExecutionClientCore,
78 clock: &'static AtomicTime,
79 config: DeribitExecutionClientConfig,
80 emitter: ExecutionEventEmitter,
81 http_client: DeribitHttpClient,
82 ws_client: DeribitWebSocketClient,
83 session_tasks: TaskGroup,
84 pending_tasks: TaskGroup,
85}
86
87impl DeribitExecutionClient {
88 pub fn new(
94 core: ExecutionClientCore,
95 config: DeribitExecutionClientConfig,
96 ) -> anyhow::Result<Self> {
97 config.validate()?;
98
99 let api_key = config
100 .api_key
101 .as_ref()
102 .map(|value| value.expose_secret().to_owned());
103 let api_secret = config
104 .api_secret
105 .as_ref()
106 .map(|value| value.expose_secret().to_owned());
107 let proxy_url = config
108 .proxy_url
109 .as_ref()
110 .map(|value| value.expose_secret().to_owned());
111 let http_client = if config.has_api_credentials() {
112 DeribitHttpClient::new_with_env(
113 api_key.clone(),
114 api_secret.clone(),
115 config.base_url_http.clone(),
116 config.environment,
117 config.http_timeout_secs,
118 config.max_retries,
119 config.retry_delay_initial_ms,
120 config.retry_delay_max_ms,
121 proxy_url.clone(),
122 )?
123 } else {
124 DeribitHttpClient::new(
125 config.base_url_http.clone(),
126 config.environment,
127 config.http_timeout_secs,
128 config.max_retries,
129 config.retry_delay_initial_ms,
130 config.retry_delay_max_ms,
131 proxy_url.clone(),
132 )?
133 };
134
135 let mut ws_client = DeribitWebSocketClient::new(
136 config.base_url_ws.clone(),
137 api_key,
138 api_secret,
139 DERIBIT_WS_HEARTBEAT_SECS,
140 config.auth_timeout_secs,
141 config.environment,
142 config.transport_backend,
143 proxy_url,
144 )
145 .context("failed to create WebSocket client for execution")?
146 .with_socket_control(SocketControl::new(
147 core.client_id,
148 Some(*DERIBIT_VENUE),
149 "deribit-user-streams",
150 ));
151 ws_client.set_account_id(core.account_id);
153
154 let clock = get_atomic_clock_realtime();
155 let emitter = ExecutionEventEmitter::new(
156 clock,
157 core.trader_id,
158 core.account_id,
159 AccountType::Margin,
160 None,
161 );
162
163 let session_tasks = TaskGroup::new();
164 let pending_tasks = TaskGroup::new();
165
166 Ok(Self {
167 core,
168 clock,
169 config,
170 emitter,
171 http_client,
172 ws_client,
173 session_tasks,
174 pending_tasks,
175 })
176 }
177
178 fn spawn_task<F>(&self, description: &'static str, fut: F)
180 where
181 F: Future<Output = anyhow::Result<()>> + Send + 'static,
182 {
183 let future = async move {
184 if let Err(e) = fut.await {
185 log::warn!("{description} failed: {e:?}");
186 }
187 };
188
189 if let Err(e) = self.pending_tasks.spawn(future) {
190 log::warn!("Skipping Deribit {description} after shutdown began: {e}");
191 }
192 }
193
194 fn abort_pending_tasks(&self) {
196 self.pending_tasks.begin_shutdown();
197 }
198
199 fn abort_session_tasks(&self) {
200 self.session_tasks.begin_shutdown();
201 self.ws_client.begin_shutdown();
202 }
203
204 async fn await_pending_tasks(&self) -> anyhow::Result<()> {
205 self.pending_tasks.begin_shutdown();
206 self.pending_tasks
207 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
208 .await
209 .map_err(|e| anyhow::anyhow!("Failed to terminate Deribit execution tasks: {e}"))?;
210 Ok(())
211 }
212
213 async fn await_session_tasks(&self) -> anyhow::Result<()> {
214 self.session_tasks.begin_shutdown();
215 self.session_tasks
216 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
217 .await
218 .map_err(|e| anyhow::anyhow!("Failed to terminate Deribit session tasks: {e}"))?;
219 Ok(())
220 }
221
222 async fn teardown_partial_connect(&self) -> anyhow::Result<()> {
223 self.abort_session_tasks();
224 self.abort_pending_tasks();
225
226 let mut errors = Vec::new();
227 if let Err(e) = self.ws_client.close().await {
228 errors.push(format!("WebSocket shutdown failed: {e}"));
229 }
230 let (session_result, pending_result) =
231 tokio::join!(self.await_session_tasks(), self.await_pending_tasks());
232
233 if let Err(e) = session_result {
234 errors.push(e.to_string());
235 }
236
237 if let Err(e) = pending_result {
238 errors.push(e.to_string());
239 }
240 self.core.set_disconnected();
241
242 if errors.is_empty() {
243 Ok(())
244 } else {
245 anyhow::bail!(errors.join("; "))
246 }
247 }
248
249 fn build_order_params(&self, order: &dyn Order) -> anyhow::Result<DeribitOrderParams> {
251 let instrument_id = order.instrument_id();
252 let instrument = self
253 .http_client
254 .get_instrument(&instrument_id.symbol.inner())
255 .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
256 validate_order(&instrument, order)?;
257
258 let order_type = match order.order_type() {
259 OrderType::Limit => "limit",
260 OrderType::Market => "market",
261 OrderType::StopLimit => "stop_limit",
262 OrderType::StopMarket => "stop_market",
263 OrderType::LimitIfTouched => "take_limit",
264 OrderType::MarketIfTouched => "take_market",
265 other => {
266 anyhow::bail!("Unsupported order type {other:?} for Deribit");
267 }
268 }
269 .to_string();
270
271 let time_in_force = if matches!(
272 order.order_type(),
273 OrderType::Market | OrderType::StopMarket | OrderType::MarketIfTouched
274 ) {
275 None
277 } else {
278 Some(
279 match order.time_in_force() {
280 TimeInForce::Gtc => "good_til_cancelled",
281 TimeInForce::Ioc => "immediate_or_cancel",
282 TimeInForce::Fok => "fill_or_kill",
283 TimeInForce::Gtd => {
284 if order.expire_time().is_some() {
285 log::warn!(
286 "Deribit GTD orders expire at 8:00 UTC only - custom expire_time is ignored. \
287 For custom expiry times, use managed GTD with emulation_trigger"
288 );
289 }
290 "good_til_day"
291 }
292 other => {
293 anyhow::bail!("Unsupported time_in_force {other:?} for Deribit");
294 }
295 }
296 .to_string(),
297 )
298 };
299
300 let valid_until = None;
303
304 let trigger = resolve_trigger_type(order.trigger_type());
305
306 let params = DeribitOrderParams {
307 instrument_name: order.instrument_id().symbol.to_string(),
308 amount: order.quantity().as_decimal(),
309 order_type,
310 label: Some(order.client_order_id().to_string()),
311 price: order.price().map(|p| p.as_decimal()),
312 time_in_force,
313 post_only: if order.is_post_only() {
314 Some(true)
315 } else {
316 None
317 },
318 reject_post_only: if order.is_post_only() {
319 Some(true)
320 } else {
321 None
322 },
323 reduce_only: if order.is_reduce_only() {
324 Some(true)
325 } else {
326 None
327 },
328 trigger_price: order.trigger_price().map(|p| p.as_decimal()),
329 trigger,
330 max_show: None,
331 valid_until,
332 };
333
334 check_params_serialize(¶ms)?;
335
336 Ok(params)
337 }
338
339 fn spawn_order_submit(
340 &self,
341 order: &OrderAny,
342 params: DeribitOrderParams,
343 task_name: &'static str,
344 ) {
345 let client_order_id = order.client_order_id();
346 let trader_id = order.trader_id();
347 let strategy_id = order.strategy_id();
348 let instrument_id = order.instrument_id();
349 let order_side = order.order_side();
350
351 log::debug!("OrderSubmitted client_order_id={client_order_id}");
352
353 let ws_client = self.ws_client.clone();
354 let emitter = self.emitter.clone();
355 let clock = self.clock;
356
357 let future = async move {
358 if let Err(e) = ws_client
359 .submit_order(
360 order_side,
361 params,
362 client_order_id,
363 trader_id,
364 strategy_id,
365 instrument_id,
366 )
367 .await
368 {
369 emit_if_not_sent(&e, client_order_id, "Submit order", |reason| {
370 emitter.emit_order_rejected_event(
371 strategy_id,
372 instrument_id,
373 client_order_id,
374 reason,
375 clock.get_time_ns(),
376 false,
377 );
378 });
379 }
380 };
381
382 if let Err(e) = self.pending_tasks.spawn(future) {
383 log::warn!(
384 "Submit order was not started: task={task_name}, client_order_id={client_order_id}, error={e}"
385 );
386 self.emitter.emit_order_rejected_event(
387 strategy_id,
388 instrument_id,
389 client_order_id,
390 REASON_NOT_STARTED,
391 self.clock.get_time_ns(),
392 false,
393 );
394 }
395 }
396
397 fn spawn_stream_handler(
399 &self,
400 stream: impl futures_util::Stream<Item = NautilusWsMessage> + Send + 'static,
401 ) -> anyhow::Result<()> {
402 let emitter = self.emitter.clone();
403
404 self.session_tasks.spawn(async move {
405 pin_mut!(stream);
406 while let Some(message) = stream.next().await {
407 dispatch_ws_message(message, &emitter);
408 }
409 })?;
410
411 log::debug!("WebSocket stream handler started");
412 Ok(())
413 }
414
415 async fn load_execution_instruments(&self) -> anyhow::Result<()> {
416 if self.core.instruments_initialized() {
417 return Ok(());
418 }
419
420 for product_type in &self.config.product_types {
421 let instruments = self
422 .http_client
423 .request_instruments(DeribitCurrency::ANY, Some(*product_type))
424 .await
425 .with_context(|| format!("failed to request instruments for {product_type:?}"))?;
426
427 if instruments.is_empty() {
428 log::warn!("No instruments returned for {product_type:?}");
429 continue;
430 }
431
432 log::debug!("Fetched {} {product_type:?} instruments", instruments.len());
433 self.ws_client.cache_instruments(&instruments);
434 self.http_client.cache_instruments(&instruments);
435 }
436
437 let required = self
438 .http_client
439 .request_uncached_instruments(self.config.load_ids.as_deref().unwrap_or(&[]))
440 .await
441 .context("failed to load reconciliation instruments")?;
442
443 if !required.is_empty() {
444 self.ws_client.cache_instruments(&required);
445 self.http_client.cache_instruments(&required);
446 }
447
448 self.core.set_instruments_initialized();
449 Ok(())
450 }
451
452 fn reconciliation_scope(&self) -> ReconciliationScope {
453 ReconciliationScope::from_load_ids(self.config.load_ids.as_deref())
454 }
455}
456
457#[async_trait(?Send)]
458impl ExecutionClient for DeribitExecutionClient {
459 fn is_connected(&self) -> bool {
460 self.core.is_connected()
461 }
462
463 fn client_id(&self) -> ClientId {
464 self.core.client_id
465 }
466
467 fn account_id(&self) -> AccountId {
468 self.core.account_id
469 }
470
471 fn venue(&self) -> Venue {
472 *DERIBIT_VENUE
473 }
474
475 fn oms_type(&self) -> OmsType {
476 self.core.oms_type
477 }
478
479 fn get_account(&self) -> Option<AccountAny> {
480 self.core.cache().account_owned(&self.core.account_id)
481 }
482
483 fn generate_account_state(
484 &self,
485 balances: Vec<AccountBalance>,
486 margins: Vec<MarginBalance>,
487 reported: bool,
488 ts_event: UnixNanos,
489 info: Option<Params>,
490 ) -> anyhow::Result<()> {
491 self.emitter
492 .emit_account_state(balances, margins, reported, ts_event, info);
493 Ok(())
494 }
495
496 fn start(&mut self) -> anyhow::Result<()> {
497 if self.core.is_started() {
498 return Ok(());
499 }
500
501 let sender = get_exec_event_sender();
502 self.emitter.set_sender(sender);
503 self.core.set_started();
504
505 log::info!(
506 "Started: client_id={}, account_id={}, account_type={:?}, product_types={:?}, environment={}",
507 self.core.client_id,
508 self.core.account_id,
509 self.core.account_type,
510 self.config.product_types,
511 self.config.environment
512 );
513 Ok(())
514 }
515
516 fn stop(&mut self) -> anyhow::Result<()> {
517 if self.core.is_stopped() {
518 return Ok(());
519 }
520
521 self.core.set_stopped();
522 self.core.set_disconnected();
523 self.abort_session_tasks();
524 self.abort_pending_tasks();
525 log::info!("Stopped: client_id={}", self.core.client_id);
526 Ok(())
527 }
528
529 async fn connect(&mut self) -> anyhow::Result<()> {
530 if self.core.is_connected() && self.pending_tasks.is_open() && self.session_tasks.is_open()
531 {
532 return Ok(());
533 }
534
535 if !self.pending_tasks.is_open() {
536 self.await_pending_tasks().await?;
537 self.pending_tasks
538 .start_generation()
539 .map_err(|e| anyhow::anyhow!("Failed to start Deribit task generation: {e}"))?;
540 }
541
542 if !self.session_tasks.is_open() || !self.session_tasks.is_empty() {
543 self.abort_session_tasks();
544
545 if self.ws_client.is_active() {
546 self.ws_client
547 .close()
548 .await
549 .context("failed to close stale Deribit WebSocket")?;
550 }
551 self.await_session_tasks().await?;
552 self.session_tasks
553 .start_generation()
554 .map_err(|e| anyhow::anyhow!("Failed to start Deribit session generation: {e}"))?;
555 } else if self.ws_client.is_active() {
556 self.ws_client
557 .close()
558 .await
559 .context("failed to close stale Deribit WebSocket")?;
560 }
561 let ws_client = self.ws_client.clone();
562 let setup_guard =
563 TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
564 ws_client.begin_shutdown();
565 });
566
567 if !self.config.has_api_credentials() {
569 anyhow::bail!("Missing API credentials; set Deribit environment variables");
570 }
571
572 self.ws_client.set_account_id(self.core.account_id);
574
575 self.load_execution_instruments().await?;
576
577 let account_state = self
579 .http_client
580 .request_account_state(self.core.account_id)
581 .await
582 .context("failed to request account state")?;
583
584 self.emitter.send_account_state(account_state);
585
586 let session_result = async {
587 self.ws_client
588 .connect()
589 .await
590 .context("failed to connect WebSocket client for execution")?;
591
592 self.ws_client
593 .authenticate_session(DERIBIT_EXECUTION_SESSION_NAME)
594 .await
595 .map_err(|e| anyhow::anyhow!("failed to authenticate WebSocket session: {e}"))?;
596
597 log::debug!("WebSocket client authenticated for execution");
598
599 self.ws_client
601 .subscribe_user_orders()
602 .await
603 .map_err(|e| anyhow::anyhow!("failed to subscribe to user orders: {e}"))?;
604 self.ws_client
605 .subscribe_user_trades()
606 .await
607 .map_err(|e| anyhow::anyhow!("failed to subscribe to user trades: {e}"))?;
608 self.ws_client
609 .subscribe_user_portfolio()
610 .await
611 .map_err(|e| anyhow::anyhow!("failed to subscribe to user portfolio: {e}"))?;
612
613 if let Err(e) = self.ws_client.wait_for_subscriptions_confirmed(30.0).await {
614 let _ = self.ws_client.unsubscribe_user_orders().await;
616 let _ = self.ws_client.unsubscribe_user_trades().await;
617 let _ = self.ws_client.unsubscribe_user_portfolio().await;
618 anyhow::bail!("subscription confirmation failed: {e}");
619 }
620
621 log::debug!("Subscribed to user order, trade, and portfolio updates");
622
623 let stream = self.ws_client.stream()?;
625 self.spawn_stream_handler(stream)?;
626
627 Ok::<(), anyhow::Error>(())
628 }
629 .await;
630
631 if let Err(e) = session_result {
632 if let Err(teardown_error) = self.teardown_partial_connect().await {
633 return Err(e.context(format!(
634 "Deribit execution startup teardown failed: {teardown_error}"
635 )));
636 }
637 return Err(e);
638 }
639
640 self.core.set_connected();
641 setup_guard.disarm();
642 log::info!("Connected: client_id={}", self.core.client_id);
643 Ok(())
644 }
645
646 async fn disconnect(&mut self) -> anyhow::Result<()> {
647 self.teardown_partial_connect().await?;
648 log::info!("Disconnected: client_id={}", self.core.client_id);
649 Ok(())
650 }
651
652 fn generate_order_status_report_task(
653 &self,
654 cmd: &GenerateOrderStatusReport,
655 ) -> Option<ExecutionReportTask<Option<OrderStatusReport>>> {
656 let http_client = self.http_client.clone();
657 let account_id = self.core.account_id;
658 let scope = self.reconciliation_scope();
659 let ts_init = self.clock.get_time_ns();
660 let command = cmd.clone();
661 Some(ExecutionReportTask::new(
662 async move {
663 collect_order_status_report(http_client, account_id, command, scope, ts_init).await
664 },
665 Ok,
666 ))
667 }
668
669 fn generate_order_status_reports_task(
670 &self,
671 cmd: &GenerateOrderStatusReports,
672 ) -> Option<ExecutionReportTask<Vec<OrderStatusReport>>> {
673 let http_client = self.http_client.clone();
674 let account_id = self.core.account_id;
675 let scope = self.reconciliation_scope();
676 let command = cmd.clone();
677 Some(ExecutionReportTask::new(
678 async move { collect_order_status_reports(http_client, account_id, command, scope).await },
679 Ok,
680 ))
681 }
682
683 fn generate_fill_reports_task(
684 &self,
685 cmd: &GenerateFillReports,
686 ) -> Option<ExecutionReportTask<Vec<FillReport>>> {
687 let http_client = self.http_client.clone();
688 let account_id = self.core.account_id;
689 let scope = self.reconciliation_scope();
690 let command = cmd.clone();
691 Some(ExecutionReportTask::new(
692 async move { collect_fill_reports(http_client, account_id, command, scope).await },
693 Ok,
694 ))
695 }
696
697 fn generate_position_status_reports_task(
698 &self,
699 cmd: &GeneratePositionStatusReports,
700 ) -> Option<ExecutionReportTask<Vec<PositionStatusReport>>> {
701 let http_client = self.http_client.clone();
702 let account_id = self.core.account_id;
703 let scope = self.reconciliation_scope();
704 let command = cmd.clone();
705 Some(ExecutionReportTask::new(
706 async move {
707 collect_position_status_reports(http_client, account_id, command, scope).await
708 },
709 Ok,
710 ))
711 }
712
713 async fn generate_order_status_report(
714 &self,
715 cmd: &GenerateOrderStatusReport,
716 ) -> anyhow::Result<Option<OrderStatusReport>> {
717 collect_order_status_report(
718 self.http_client.clone(),
719 self.core.account_id,
720 cmd.clone(),
721 self.reconciliation_scope(),
722 self.clock.get_time_ns(),
723 )
724 .await
725 }
726
727 async fn generate_order_status_reports(
728 &self,
729 cmd: &GenerateOrderStatusReports,
730 ) -> anyhow::Result<Vec<OrderStatusReport>> {
731 collect_order_status_reports(
732 self.http_client.clone(),
733 self.core.account_id,
734 cmd.clone(),
735 self.reconciliation_scope(),
736 )
737 .await
738 }
739
740 async fn generate_fill_reports(
741 &self,
742 cmd: GenerateFillReports,
743 ) -> anyhow::Result<Vec<FillReport>> {
744 collect_fill_reports(
745 self.http_client.clone(),
746 self.core.account_id,
747 cmd,
748 self.reconciliation_scope(),
749 )
750 .await
751 }
752
753 async fn generate_position_status_reports(
754 &self,
755 cmd: &GeneratePositionStatusReports,
756 ) -> anyhow::Result<Vec<PositionStatusReport>> {
757 collect_position_status_reports(
758 self.http_client.clone(),
759 self.core.account_id,
760 cmd.clone(),
761 self.reconciliation_scope(),
762 )
763 .await
764 }
765
766 async fn generate_mass_status(
767 &self,
768 lookback_mins: Option<u64>,
769 ) -> anyhow::Result<Option<ExecutionMassStatus>> {
770 log::info!("Generating ExecutionMassStatus (lookback_mins={lookback_mins:?})");
771 let ts_now = self.clock.get_time_ns();
772 let start = lookback_mins
773 .map(DurationNanos::try_from_mins)
774 .transpose()?
775 .map(|lookback| ts_now.saturating_sub(lookback));
776
777 let scope = self.reconciliation_scope();
778 let (order_read, fill_read, position_read) = tokio::try_join!(
779 self.http_client.request_order_status_reports_in_scope(
780 self.core.account_id,
781 None,
782 start,
783 None,
784 false,
785 scope.clone(),
786 ),
787 self.http_client.request_fill_reports_scoped(
788 self.core.account_id,
789 None,
790 start,
791 None,
792 None,
793 scope.clone(),
794 ),
795 self.http_client.request_position_status_reports_in_scope(
796 self.core.account_id,
797 None,
798 scope,
799 ),
800 )?;
801 let historical_incomplete = order_read.historical_incomplete()
802 || fill_read.historical_incomplete()
803 || position_read.historical_incomplete();
804 let order_reports = order_read.reports;
805 let fill_reports = fill_read.reports;
806 let position_reports = position_read.reports;
807
808 log::info!("Received {} OrderStatusReports", order_reports.len());
809 log::info!("Received {} FillReports", fill_reports.len());
810 log::info!("Received {} PositionReports", position_reports.len());
811
812 let mut mass_status = ExecutionMassStatus::new(
813 self.core.client_id,
814 self.core.account_id,
815 *DERIBIT_VENUE,
816 ts_now,
817 None,
818 );
819
820 mass_status.add_order_reports(order_reports);
821 mass_status.add_fill_reports(fill_reports);
822 mass_status.add_position_reports(position_reports);
823
824 if start.is_some() && historical_incomplete {
825 add_flat_reports_without_position(
826 &mut mass_status,
827 &self.http_client,
828 self.core.account_id,
829 ts_now,
830 );
831 mass_status.set_report_window(start, false);
832 }
833
834 Ok(Some(mass_status))
835 }
836
837 fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
838 let http_client = self.http_client.clone();
839 let account_id = self.core.account_id;
840 let emitter = self.emitter.clone();
841
842 self.spawn_task("query_account", async move {
843 let account_state = http_client
844 .request_account_state(account_id)
845 .await
846 .context("failed to query account state (check API credentials are valid)")?;
847
848 emitter.send_account_state(account_state);
849 Ok(())
850 });
851
852 Ok(())
853 }
854
855 fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
856 let ws_client = self.ws_client.clone();
857
858 let order_id = cmd
860 .venue_order_id
861 .as_ref()
862 .ok_or_else(|| anyhow::anyhow!("venue_order_id required for query_order"))?
863 .to_string();
864
865 let client_order_id = cmd.client_order_id;
866 let trader_id = cmd.trader_id;
867 let strategy_id = cmd.strategy_id;
868 let instrument_id = cmd.instrument_id;
869
870 log::debug!("Querying order state: order_id={order_id}, client_order_id={client_order_id}");
871
872 self.spawn_task("query_order", async move {
875 ws_client
876 .query_order(
877 &order_id,
878 client_order_id,
879 trader_id,
880 strategy_id,
881 instrument_id,
882 )
883 .await
884 .map_err(|e| anyhow::anyhow!("Query order state failed: {e}"))?;
885 Ok(())
886 });
887
888 Ok(())
889 }
890
891 fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
892 let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
893 if order.is_closed() {
894 log::warn!("Cannot submit closed order {}", order.client_order_id());
895 return Ok(());
896 }
897
898 let params = self.build_order_params(&order)?;
899 self.emitter.try_emit_order_submitted(&order)?;
900 self.spawn_order_submit(&order, params, "submit_order");
901 Ok(())
902 }
903
904 fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
905 if cmd.order_list.client_order_ids.is_empty() {
906 log::debug!("submit_order_list called with empty order list");
907 return Ok(());
908 }
909
910 let mut orders = self.core.get_orders_for_list(&cmd.order_list)?;
911 orders.retain(|order| {
912 if order.is_closed() {
913 log::warn!("Cannot submit closed order {}", order.client_order_id());
914 false
915 } else {
916 true
917 }
918 });
919
920 if orders.is_empty() {
921 return Ok(());
922 }
923
924 let params = orders
925 .iter()
926 .map(|order| self.build_order_params(order))
927 .collect::<anyhow::Result<Vec<_>>>()?;
928
929 for order in &orders {
930 self.emitter.try_emit_order_submitted(order)?;
931 }
932
933 log::debug!(
934 "Submitting order list {} with {} orders for instrument={}",
935 cmd.order_list.id,
936 orders.len(),
937 cmd.instrument_id
938 );
939
940 for (order, params) in orders.iter().zip(params) {
941 self.spawn_order_submit(order, params, "submit_order_list_item");
942 }
943
944 Ok(())
945 }
946
947 fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
948 let ws_client = self.ws_client.clone();
949 let cached_order = self
950 .core
951 .cache()
952 .order(&cmd.client_order_id)
953 .map(|order| order.clone());
954
955 let order_id = match cmd.venue_order_id.as_ref() {
957 Some(venue_order_id) => venue_order_id.to_string(),
958 None => {
959 return deny_modify_command(
960 &self.emitter,
961 self.clock,
962 &cmd,
963 "venue_order_id required for modify_order",
964 cached_order.as_ref(),
965 );
966 }
967 };
968
969 let quantity = if let Some(qty) = cmd.quantity {
971 qty
972 } else {
973 let cache = self.core.cache();
975 match cache.order(&cmd.client_order_id) {
976 Some(order) => order.quantity(),
977 None => {
978 return deny_modify_command(
979 &self.emitter,
980 self.clock,
981 &cmd,
982 &format!("Order not found: {}", cmd.client_order_id),
983 cached_order.as_ref(),
984 );
985 }
986 }
987 };
988
989 let price = match cmd.price {
990 Some(price) => price,
991 None => {
992 return deny_modify_command(
993 &self.emitter,
994 self.clock,
995 &cmd,
996 "price required for modify_order",
997 cached_order.as_ref(),
998 );
999 }
1000 };
1001
1002 let client_order_id = cmd.client_order_id;
1003 let trader_id = cached_order
1004 .as_ref()
1005 .map_or(cmd.trader_id, |order| order.trader_id());
1006 let strategy_id = cached_order
1007 .as_ref()
1008 .map_or(cmd.strategy_id, |order| order.strategy_id());
1009 let instrument_id = cached_order
1010 .as_ref()
1011 .map_or(cmd.instrument_id, |order| order.instrument_id());
1012
1013 log::debug!(
1014 "Modifying order: order_id={order_id}, quantity={quantity}, price={price}, client_order_id={client_order_id}"
1015 );
1016
1017 let params = DeribitEditParams {
1018 order_id: order_id.clone(),
1019 amount: quantity.as_decimal(),
1020 price: Some(price.as_decimal()),
1021 post_only: None,
1022 reject_post_only: None,
1023 reduce_only: None,
1024 trigger_price: None,
1025 };
1026
1027 if let Err(e) = check_params_serialize(¶ms) {
1028 return deny_modify_command(
1029 &self.emitter,
1030 self.clock,
1031 &cmd,
1032 &e.to_string(),
1033 cached_order.as_ref(),
1034 );
1035 }
1036
1037 let emitter = self.emitter.clone();
1038 let clock = self.clock;
1039 let venue_order_id = VenueOrderId::new(order_id.as_str());
1040 let command_id = cmd.command_id;
1041
1042 let future = async move {
1043 if let Err(e) = ws_client
1044 .modify_order_with_causation(
1045 params,
1046 client_order_id,
1047 trader_id,
1048 strategy_id,
1049 instrument_id,
1050 Some(command_id),
1051 )
1052 .await
1053 {
1054 emit_if_not_sent(&e, client_order_id, "Modify order", |reason| {
1055 emitter.emit_order_modify_denied_event(
1056 strategy_id,
1057 instrument_id,
1058 client_order_id,
1059 Some(venue_order_id),
1060 reason,
1061 clock.get_time_ns(),
1062 Some(command_id),
1063 );
1064 });
1065 }
1066 };
1067
1068 if let Err(e) = self.pending_tasks.spawn(future) {
1069 log::warn!(
1070 "Modify order was not started: order_id={order_id}, client_order_id={client_order_id}, error={e}"
1071 );
1072 self.emitter.emit_order_modify_denied_event(
1073 strategy_id,
1074 instrument_id,
1075 client_order_id,
1076 Some(venue_order_id),
1077 REASON_NOT_STARTED,
1078 self.clock.get_time_ns(),
1079 Some(command_id),
1080 );
1081 }
1082
1083 Ok(())
1084 }
1085
1086 fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1087 let ws_client = self.ws_client.clone();
1088 let cached_order = self
1089 .core
1090 .cache()
1091 .order(&cmd.client_order_id)
1092 .map(|order| order.clone());
1093
1094 let order_id = match cmd.venue_order_id.as_ref() {
1096 Some(venue_order_id) => venue_order_id.to_string(),
1097 None => {
1098 deny_cancel_command(
1099 &self.emitter,
1100 self.clock,
1101 &cmd,
1102 cached_order.as_ref(),
1103 "venue_order_id required for cancel_order",
1104 );
1105 return Ok(());
1106 }
1107 };
1108
1109 let client_order_id = cmd.client_order_id;
1110 let trader_id = cached_order
1111 .as_ref()
1112 .map_or(cmd.trader_id, |order| order.trader_id());
1113 let strategy_id = cached_order
1114 .as_ref()
1115 .map_or(cmd.strategy_id, |order| order.strategy_id());
1116 let instrument_id = cached_order
1117 .as_ref()
1118 .map_or(cmd.instrument_id, |order| order.instrument_id());
1119
1120 log::debug!("Canceling order: order_id={order_id}, client_order_id={client_order_id}");
1121
1122 let emitter = self.emitter.clone();
1123 let clock = self.clock;
1124 let venue_order_id = VenueOrderId::new(order_id.as_str());
1125 let command_id = cmd.command_id;
1126 let order_id_for_task = order_id.clone();
1127
1128 let future = async move {
1129 if let Err(e) = ws_client
1130 .cancel_order_with_causation(
1131 &order_id_for_task,
1132 client_order_id,
1133 trader_id,
1134 strategy_id,
1135 instrument_id,
1136 Some(command_id),
1137 )
1138 .await
1139 {
1140 emit_if_not_sent(&e, client_order_id, "Cancel order", |reason| {
1141 emitter.emit_order_cancel_denied_event(
1142 strategy_id,
1143 instrument_id,
1144 client_order_id,
1145 Some(venue_order_id),
1146 reason,
1147 clock.get_time_ns(),
1148 Some(command_id),
1149 );
1150 });
1151 }
1152 };
1153
1154 if let Err(e) = self.pending_tasks.spawn(future) {
1155 log::warn!(
1156 "Cancel order was not started: order_id={order_id}, client_order_id={client_order_id}, error={e}"
1157 );
1158 self.emitter.emit_order_cancel_denied_event(
1159 strategy_id,
1160 instrument_id,
1161 client_order_id,
1162 Some(venue_order_id),
1163 REASON_NOT_STARTED,
1164 self.clock.get_time_ns(),
1165 Some(command_id),
1166 );
1167 }
1168
1169 Ok(())
1170 }
1171
1172 fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
1173 let instrument_id = cmd.instrument_id;
1174
1175 let Some(order_side) = cmd.order_side else {
1177 log::debug!(
1178 "Cancelling all orders: instrument={instrument_id}, order_side=None (bulk)"
1179 );
1180
1181 let ws_client = self.ws_client.clone();
1182 let future = async move {
1183 if let Err(e) = ws_client.cancel_all_orders(instrument_id, None).await {
1184 log::warn!(
1185 "Cancel all orders failed for {instrument_id}, awaiting reconciliation: {e}"
1186 );
1187 }
1188 };
1189
1190 if let Err(e) = self.pending_tasks.spawn(future) {
1191 log::warn!(
1192 "Cancel all orders was not started for {instrument_id}, awaiting reconciliation: {e}"
1193 );
1194 }
1195
1196 return Ok(());
1197 };
1198
1199 log::debug!(
1202 "Cancelling orders by side: instrument={instrument_id}, order_side={order_side}"
1203 );
1204
1205 let open_orders: Vec<_> = {
1206 let cache = self.core.cache();
1207 let open_orders = cache.orders_open(None, Some(&instrument_id), None, None, None);
1208
1209 open_orders
1210 .into_iter()
1211 .filter(|order| order.order_side() == order_side)
1212 .map(|order| order.clone())
1213 .collect()
1214 };
1215
1216 let orders_to_cancel: Vec<_> = open_orders
1217 .into_iter()
1218 .filter_map(|order| {
1219 let Some(venue_order_id) = order.venue_order_id() else {
1220 self.emitter.emit_order_cancel_denied(
1221 &order,
1222 "venue_order_id required for cancel_order",
1223 self.clock.get_time_ns(),
1224 Some(cmd.command_id),
1225 );
1226 return None;
1227 };
1228
1229 Some((
1230 venue_order_id.to_string(),
1231 order.client_order_id(),
1232 order.instrument_id(),
1233 Some(venue_order_id),
1234 order.trader_id(),
1235 order.strategy_id(),
1236 ))
1237 })
1238 .collect();
1239
1240 if orders_to_cancel.is_empty() {
1241 log::debug!("No open {order_side} orders to cancel for {instrument_id}");
1242 return Ok(());
1243 }
1244
1245 log::debug!(
1246 "Cancelling {} {order_side} orders for {instrument_id}",
1247 orders_to_cancel.len(),
1248 );
1249
1250 for (
1252 venue_order_id_str,
1253 client_order_id,
1254 order_instrument_id,
1255 venue_order_id,
1256 trader_id,
1257 strategy_id,
1258 ) in orders_to_cancel
1259 {
1260 let ws_client = self.ws_client.clone();
1261 let emitter = self.emitter.clone();
1262 let clock = self.clock;
1263 let cause = cmd.command_id;
1264 let venue_order_id_for_task = venue_order_id_str.clone();
1265
1266 let future = async move {
1267 if let Err(e) = ws_client
1268 .cancel_order_with_causation(
1269 &venue_order_id_for_task,
1270 client_order_id,
1271 trader_id,
1272 strategy_id,
1273 order_instrument_id,
1274 Some(cause),
1275 )
1276 .await
1277 {
1278 emit_if_not_sent(&e, client_order_id, "Cancel order", |reason| {
1279 emitter.emit_order_cancel_denied_event(
1280 strategy_id,
1281 order_instrument_id,
1282 client_order_id,
1283 venue_order_id,
1284 reason,
1285 clock.get_time_ns(),
1286 Some(cause),
1287 );
1288 });
1289 }
1290 };
1291
1292 if let Err(e) = self.pending_tasks.spawn(future) {
1293 log::warn!(
1294 "Cancel order was not started: order_id={venue_order_id_str}, client_order_id={client_order_id}, error={e}"
1295 );
1296 self.emitter.emit_order_cancel_denied_event(
1297 strategy_id,
1298 order_instrument_id,
1299 client_order_id,
1300 venue_order_id,
1301 REASON_NOT_STARTED,
1302 self.clock.get_time_ns(),
1303 Some(cause),
1304 );
1305 }
1306 }
1307
1308 Ok(())
1309 }
1310
1311 fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
1312 if cmd.cancels.is_empty() {
1313 log::debug!("batch_cancel_orders called with empty cancels list");
1314 return Ok(());
1315 }
1316
1317 log::debug!(
1318 "Batch cancelling {} orders for instrument={}",
1319 cmd.cancels.len(),
1320 cmd.instrument_id
1321 );
1322
1323 for cancel in &cmd.cancels {
1326 let cached_order = self
1327 .core
1328 .cache()
1329 .order(&cancel.client_order_id)
1330 .map(|order| order.clone());
1331
1332 let order_id = match &cancel.venue_order_id {
1333 Some(id) => id.to_string(),
1334 None => {
1335 deny_cancel_command(
1336 &self.emitter,
1337 self.clock,
1338 cancel,
1339 cached_order.as_ref(),
1340 "venue_order_id required for cancel_order",
1341 );
1342 continue;
1343 }
1344 };
1345
1346 let emitter = self.emitter.clone();
1347 let clock = self.clock;
1348 let command_id = cancel.command_id;
1349 let ws_client = self.ws_client.clone();
1350 let client_order_id = cancel.client_order_id;
1351 let trader_id = cached_order
1352 .as_ref()
1353 .map_or(cancel.trader_id, |order| order.trader_id());
1354 let strategy_id = cached_order
1355 .as_ref()
1356 .map_or(cancel.strategy_id, |order| order.strategy_id());
1357 let instrument_id = cached_order
1358 .as_ref()
1359 .map_or(cancel.instrument_id, |order| order.instrument_id());
1360 let venue_order_id = VenueOrderId::new(order_id.as_str());
1361 let order_id_for_task = order_id.clone();
1362
1363 let future = async move {
1364 if let Err(e) = ws_client
1365 .cancel_order_with_causation(
1366 &order_id_for_task,
1367 client_order_id,
1368 trader_id,
1369 strategy_id,
1370 instrument_id,
1371 Some(command_id),
1372 )
1373 .await
1374 {
1375 emit_if_not_sent(&e, client_order_id, "Cancel order", |reason| {
1376 emitter.emit_order_cancel_denied_event(
1377 strategy_id,
1378 instrument_id,
1379 client_order_id,
1380 Some(venue_order_id),
1381 reason,
1382 clock.get_time_ns(),
1383 Some(command_id),
1384 );
1385 });
1386 }
1387 };
1388
1389 if let Err(e) = self.pending_tasks.spawn(future) {
1390 log::warn!(
1391 "Batch cancel order was not started: order_id={order_id}, client_order_id={client_order_id}, error={e}"
1392 );
1393 self.emitter.emit_order_cancel_denied_event(
1394 strategy_id,
1395 instrument_id,
1396 client_order_id,
1397 Some(venue_order_id),
1398 REASON_NOT_STARTED,
1399 self.clock.get_time_ns(),
1400 Some(command_id),
1401 );
1402 }
1403 }
1404
1405 Ok(())
1406 }
1407}
1408
1409async fn collect_order_status_report(
1410 http_client: DeribitHttpClient,
1411 account_id: AccountId,
1412 cmd: GenerateOrderStatusReport,
1413 scope: ReconciliationScope,
1414 ts_init: UnixNanos,
1415) -> anyhow::Result<Option<OrderStatusReport>> {
1416 let report = if let Some(venue_order_id) = &cmd.venue_order_id {
1417 let params = GetOrderStateParams {
1418 order_id: venue_order_id.to_string(),
1419 };
1420
1421 let response = match http_client.inner.get_order_state(params).await {
1422 Ok(response) => response,
1423 Err(DeribitHttpError::DeribitError {
1424 error_code: 10004, ..
1425 }) => return Ok(None),
1426 Err(e) => return Err(e.into()),
1427 };
1428
1429 let order = response.result.context("missing order state result")?;
1430 let instrument_id = InstrumentId::new(order.instrument_name.into(), *DERIBIT_VENUE);
1431 let instrument = http_client
1432 .get_instrument(&order.instrument_name)
1433 .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
1434
1435 parse_user_order_msg(&order, &instrument, account_id, ts_init)?
1436 } else if let Some(client_order_id) = &cmd.client_order_id {
1437 let reports = http_client
1438 .request_order_status_reports_in_scope(
1439 account_id,
1440 cmd.instrument_id,
1441 None,
1442 None,
1443 false, scope,
1445 )
1446 .await?
1447 .reports;
1448
1449 reports
1451 .into_iter()
1452 .find(|report| report.client_order_id == Some(*client_order_id))
1453 .context("order lookup by client order ID was inconclusive")?
1454 } else {
1455 anyhow::bail!("Order lookup requires a client order ID or venue order ID");
1456 };
1457
1458 anyhow::ensure!(
1460 cmd.instrument_id
1461 .is_none_or(|id| report.instrument_id == id)
1462 && report
1463 .client_order_id
1464 .zip(cmd.client_order_id)
1465 .is_none_or(|(reported, queried)| reported == queried)
1466 && cmd
1467 .venue_order_id
1468 .is_none_or(|id| report.venue_order_id == id),
1469 "Order status report identity does not match query: instrument_id={}, client_order_id={:?}, venue_order_id={}",
1470 report.instrument_id,
1471 report.client_order_id,
1472 report.venue_order_id,
1473 );
1474
1475 Ok(Some(report))
1476}
1477
1478async fn collect_order_status_reports(
1479 http_client: DeribitHttpClient,
1480 account_id: AccountId,
1481 cmd: GenerateOrderStatusReports,
1482 scope: ReconciliationScope,
1483) -> anyhow::Result<Vec<OrderStatusReport>> {
1484 let read = http_client
1485 .request_order_status_reports_in_scope(
1486 account_id,
1487 cmd.instrument_id,
1488 cmd.start,
1489 cmd.end,
1490 cmd.open_only,
1491 scope,
1492 )
1493 .await?;
1494 read.into_reports()
1495}
1496
1497async fn collect_fill_reports(
1498 http_client: DeribitHttpClient,
1499 account_id: AccountId,
1500 cmd: GenerateFillReports,
1501 scope: ReconciliationScope,
1502) -> anyhow::Result<Vec<FillReport>> {
1503 let read = http_client
1504 .request_fill_reports_scoped(
1505 account_id,
1506 cmd.instrument_id,
1507 cmd.start,
1508 cmd.end,
1509 cmd.venue_order_id.as_ref(),
1510 scope,
1511 )
1512 .await?;
1513 read.into_reports()
1514}
1515
1516async fn collect_position_status_reports(
1517 http_client: DeribitHttpClient,
1518 account_id: AccountId,
1519 cmd: GeneratePositionStatusReports,
1520 scope: ReconciliationScope,
1521) -> anyhow::Result<Vec<PositionStatusReport>> {
1522 Ok(http_client
1523 .request_position_status_reports_in_scope(account_id, cmd.instrument_id, scope)
1524 .await?
1525 .reports)
1526}
1527
1528fn add_flat_reports_without_position(
1529 mass_status: &mut ExecutionMassStatus,
1530 http_client: &DeribitHttpClient,
1531 account_id: AccountId,
1532 ts_init: UnixNanos,
1533) {
1534 let reported: Vec<InstrumentId> = mass_status.position_reports().keys().copied().collect();
1535 let mut missing = Vec::new();
1536
1537 for report in mass_status.order_reports().values() {
1538 if position_snapshot_covers(http_client, report.instrument_id)
1539 && !reported.contains(&report.instrument_id)
1540 && !missing.contains(&report.instrument_id)
1541 {
1542 missing.push(report.instrument_id);
1543 }
1544 }
1545
1546 for fills in mass_status.fill_reports().values() {
1547 let Some(fill) = fills.first() else {
1548 continue;
1549 };
1550
1551 if position_snapshot_covers(http_client, fill.instrument_id)
1552 && !reported.contains(&fill.instrument_id)
1553 && !missing.contains(&fill.instrument_id)
1554 {
1555 missing.push(fill.instrument_id);
1556 }
1557 }
1558
1559 missing.sort();
1560 if missing.is_empty() {
1561 return;
1562 }
1563
1564 let flats = missing
1565 .into_iter()
1566 .map(|instrument_id| {
1567 PositionStatusReport::new(
1568 account_id,
1569 instrument_id,
1570 PositionSide::Flat,
1571 Quantity::from("0"),
1572 ts_init,
1573 ts_init,
1574 None,
1575 None,
1576 None,
1577 )
1578 })
1579 .collect();
1580
1581 mass_status.add_position_reports(flats);
1582}
1583
1584fn position_snapshot_covers(http_client: &DeribitHttpClient, instrument_id: InstrumentId) -> bool {
1585 http_client
1586 .get_instrument(&instrument_id.symbol.inner())
1587 .is_some_and(|instrument| !matches!(instrument, InstrumentAny::CurrencyPair(_)))
1588}
1589
1590fn dispatch_ws_message(message: NautilusWsMessage, emitter: &ExecutionEventEmitter) {
1592 match message {
1593 NautilusWsMessage::AccountState(state) => {
1594 emitter.send_account_state(state);
1595 }
1596 NautilusWsMessage::OrderStatusReports(reports) => {
1597 log::debug!("Processing {} order status report(s)", reports.len());
1598 for report in reports {
1599 emitter.send_order_status_report(report);
1600 }
1601 }
1602 NautilusWsMessage::FillReports(reports) => {
1603 log::debug!("Processing {} fill report(s)", reports.len());
1604 for report in reports {
1605 emitter.send_fill_report(report);
1606 }
1607 }
1608 NautilusWsMessage::OrderFilled(event) => {
1609 emitter.send_order_event(OrderEventAny::Filled(event));
1610 }
1611 NautilusWsMessage::OrderRejected(event) => {
1612 emitter.send_order_event(OrderEventAny::Rejected(event));
1613 }
1614 NautilusWsMessage::OrderAccepted(event) => {
1615 emitter.send_order_event(OrderEventAny::Accepted(event));
1616 }
1617 NautilusWsMessage::OrderCanceled(event) => {
1618 emitter.send_order_event(OrderEventAny::Canceled(event));
1619 }
1620 NautilusWsMessage::OrderExpired(event) => {
1621 emitter.send_order_event(OrderEventAny::Expired(event));
1622 }
1623 NautilusWsMessage::OrderUpdated(event) => {
1624 emitter.send_order_event(OrderEventAny::Updated(event));
1625 }
1626 NautilusWsMessage::OrderModifyDenied(event) => {
1627 emitter.send_order_event(OrderEventAny::ModifyDenied(event));
1628 }
1629 NautilusWsMessage::OrderCancelDenied(event) => {
1630 emitter.send_order_event(OrderEventAny::CancelDenied(event));
1631 }
1632 NautilusWsMessage::OrderCancelRejected(event) => {
1633 emitter.send_order_event(OrderEventAny::CancelRejected(event));
1634 }
1635 NautilusWsMessage::OrderModifyRejected(event) => {
1636 emitter.send_order_event(OrderEventAny::ModifyRejected(event));
1637 }
1638 NautilusWsMessage::Error(e) => {
1639 log::warn!("WebSocket error: {e}");
1640 }
1641 NautilusWsMessage::Reconnected => {
1642 log::info!("WebSocket reconnected");
1643 }
1644 NautilusWsMessage::Authenticated(auth) => {
1645 log::debug!("WebSocket authenticated: scope={}", auth.scope);
1646 }
1647 NautilusWsMessage::AuthenticationFailed(reason) => {
1648 log::error!("Authentication failed in execution client: {reason}");
1649 }
1650 NautilusWsMessage::Data(_)
1651 | NautilusWsMessage::Deltas(_)
1652 | NautilusWsMessage::Instrument(_)
1653 | NautilusWsMessage::InstrumentStatus(_)
1654 | NautilusWsMessage::FundingRates(_)
1655 | NautilusWsMessage::OptionGreeks(_)
1656 | NautilusWsMessage::Raw(_) => {
1657 log::trace!("Ignoring data message in execution client");
1659 }
1660 }
1661}
1662
1663fn emit_if_not_sent(
1664 error: &DeribitWsError,
1665 client_order_id: ClientOrderId,
1666 command: &str,
1667 emit: impl FnOnce(&str),
1668) {
1669 let failure = classify_deribit_command_failure(error);
1670
1671 let Some(reason) = terminal_reason(&failure) else {
1672 log::warn!(
1673 "Ambiguous {command} failure for {client_order_id}, awaiting reconciliation: {error}"
1674 );
1675 return;
1676 };
1677
1678 log::warn!("{command} was not sent: client_order_id={client_order_id}, error={error}");
1679 emit(reason);
1680}
1681
1682fn deny_modify_command(
1683 emitter: &ExecutionEventEmitter,
1684 clock: &AtomicTime,
1685 cmd: &ModifyOrder,
1686 reason: &str,
1687 cached_order: Option<&OrderAny>,
1688) -> anyhow::Result<()> {
1689 let ts_event = clock.get_time_ns();
1690 emitter.emit_order_modify_denied_event(
1691 cached_order.map_or(cmd.strategy_id, Order::strategy_id),
1692 cached_order.map_or(cmd.instrument_id, Order::instrument_id),
1693 cmd.client_order_id,
1694 cached_order
1695 .and_then(Order::venue_order_id)
1696 .or(cmd.venue_order_id),
1697 reason,
1698 ts_event,
1699 Some(cmd.command_id),
1700 );
1701
1702 anyhow::bail!("{reason}");
1703}
1704
1705fn deny_cancel_command(
1706 emitter: &ExecutionEventEmitter,
1707 clock: &AtomicTime,
1708 cmd: &CancelOrder,
1709 cached_order: Option<&OrderAny>,
1710 reason: &str,
1711) {
1712 let ts_event = clock.get_time_ns();
1713 emitter.emit_order_cancel_denied_event(
1714 cached_order.map_or(cmd.strategy_id, Order::strategy_id),
1715 cached_order.map_or(cmd.instrument_id, Order::instrument_id),
1716 cmd.client_order_id,
1717 cached_order
1718 .and_then(Order::venue_order_id)
1719 .or(cmd.venue_order_id),
1720 reason,
1721 ts_event,
1722 Some(cmd.command_id),
1723 );
1724}
1725
1726fn check_params_serialize<T: Serialize>(params: &T) -> anyhow::Result<()> {
1729 serde_json::to_writer(io::sink(), params)
1730 .map_err(|e| anyhow::anyhow!("Cannot serialize order params: {e}"))
1731}
1732
1733#[cfg(test)]
1734mod tests {
1735 use std::{cell::RefCell, rc::Rc};
1736
1737 use nautilus_common::{
1738 cache::Cache,
1739 messages::{
1740 ExecutionEvent,
1741 execution::{CancelOrder, ExecutionReport, ModifyOrder},
1742 },
1743 };
1744 use nautilus_core::UUID4;
1745 use nautilus_model::{
1746 enums::{LiquiditySide, OrderSide, OrderStatus, TriggerType},
1747 events::{OrderDenied, OrderFilled},
1748 identifiers::{
1749 ClientOrderId, InstrumentId, OrderListId, StrategyId, TradeId, TraderId, VenueOrderId,
1750 },
1751 instruments::InstrumentAny,
1752 orders::{OrderList, OrderTestBuilder, stubs::TestOrderEventStubs},
1753 types::{Currency, Money, Price, Quantity},
1754 };
1755 use rstest::rstest;
1756
1757 use super::*;
1758 use crate::{
1759 common::{parse::parse_deribit_instrument_any, testing::routed_spot_instrument},
1760 http::models::{DeribitInstrument, DeribitJsonRpcResponse},
1761 websocket::failure::REASON_NOT_STARTED,
1762 };
1763
1764 #[rstest]
1765 #[case(OrderType::Limit, TimeInForce::Gtc, true)]
1766 #[case(OrderType::Limit, TimeInForce::Ioc, false)]
1767 #[case(OrderType::Limit, TimeInForce::Fok, false)]
1768 #[case(OrderType::Market, TimeInForce::Ioc, false)]
1769 #[case(OrderType::StopLimit, TimeInForce::Gtc, false)]
1770 fn routed_spot_supported_order_params(
1771 #[case] order_type: OrderType,
1772 #[case] tif: TimeInForce,
1773 #[case] post_only: bool,
1774 ) {
1775 let (client, _, _) = submission_test_rig(TimeInForce::Gtc);
1776 let instrument = routed_spot_instrument();
1777 client.http_client.cache_instruments(&[instrument]);
1778 let order = OrderTestBuilder::new(order_type)
1779 .instrument_id(InstrumentId::from("BTC_USDC.DERIBIT"))
1780 .quantity(Quantity::from("0.0042"))
1781 .price(Price::from("45000.25"))
1782 .trigger_price(Price::from("46000.50"))
1783 .trigger_type(TriggerType::LastPrice)
1784 .time_in_force(tif)
1785 .post_only(post_only)
1786 .build();
1787 let params = client.build_order_params(&order).unwrap();
1788
1789 assert_eq!(params.instrument_name, "BTC_USDC");
1790 assert_eq!(
1791 params.amount,
1792 rust_decimal::Decimal::from_str_exact("0.0042").unwrap()
1793 );
1794 assert_eq!(
1795 params.order_type,
1796 match order_type {
1797 OrderType::Limit => "limit",
1798 OrderType::Market => "market",
1799 OrderType::StopLimit => "stop_limit",
1800 _ => unreachable!(),
1801 }
1802 );
1803 assert_eq!(params.price, order.price().map(|price| price.as_decimal()));
1804 assert_eq!(
1805 params.time_in_force.as_deref(),
1806 if order_type == OrderType::Market {
1807 None
1808 } else {
1809 Some(match tif {
1810 TimeInForce::Gtc => "good_til_cancelled",
1811 TimeInForce::Ioc => "immediate_or_cancel",
1812 TimeInForce::Fok => "fill_or_kill",
1813 _ => unreachable!(),
1814 })
1815 }
1816 );
1817 assert_eq!(params.post_only, post_only.then_some(true));
1818 assert_eq!(params.reject_post_only, post_only.then_some(true));
1819 assert_eq!(params.reduce_only, None);
1820 assert_eq!(params.max_show, None);
1821 assert_eq!(params.valid_until, None);
1822 assert_eq!(
1823 params.trigger_price,
1824 order.trigger_price().map(|price| price.as_decimal())
1825 );
1826 assert_eq!(
1827 params.trigger.as_deref(),
1828 order.trigger_type().map(|_| "last_price")
1829 );
1830 assert_eq!(
1831 params.label.as_deref(),
1832 Some(order.client_order_id().as_str())
1833 );
1834 }
1835
1836 #[rstest]
1837 #[case(true)]
1838 #[case(false)]
1839 fn all_spot_rejects_gtd(#[case] routed: bool) {
1840 let (client, _, _) = submission_test_rig(TimeInForce::Gtc);
1841 let mut instrument = routed_spot_instrument();
1842 if !routed && let InstrumentAny::CurrencyPair(pair) = &mut instrument {
1843 pair.info = None;
1844 }
1845
1846 client.http_client.cache_instruments(&[instrument]);
1847 let order = OrderTestBuilder::new(OrderType::Limit)
1848 .instrument_id(InstrumentId::from("BTC_USDC.DERIBIT"))
1849 .quantity(Quantity::from("0.0042"))
1850 .price(Price::from("45000.25"))
1851 .time_in_force(TimeInForce::Gtd)
1852 .expire_time(UnixNanos::from(1_800_000_000_000_000_000))
1853 .build();
1854
1855 assert_eq!(
1856 client.build_order_params(&order).unwrap_err().to_string(),
1857 "Deribit spot instruments do not support good_til_day"
1858 );
1859 }
1860
1861 #[rstest]
1862 fn derivatives_preserve_gtd() {
1863 let (client, _, _) = submission_test_rig(TimeInForce::Gtc);
1864 let order = OrderTestBuilder::new(OrderType::Limit)
1865 .instrument_id(InstrumentId::from("BTC-PERPETUAL.DERIBIT"))
1866 .quantity(Quantity::from("20"))
1867 .price(Price::from("51000"))
1868 .time_in_force(TimeInForce::Gtd)
1869 .expire_time(UnixNanos::from(1_800_000_000_000_000_000))
1870 .build();
1871 let params = client.build_order_params(&order).unwrap();
1872
1873 assert_eq!(params.time_in_force.as_deref(), Some("good_til_day"));
1874 }
1875
1876 #[rstest]
1877 fn uncached_order_returns_instrument_lookup_error() {
1878 let (client, _, _) = submission_test_rig(TimeInForce::Gtc);
1879 let instrument_id = InstrumentId::from("UNCACHED.DERIBIT");
1880 let order = OrderTestBuilder::new(OrderType::Limit)
1881 .instrument_id(instrument_id)
1882 .quantity(Quantity::from("0.0042"))
1883 .price(Price::from("45000.25"))
1884 .build();
1885
1886 let error = client.build_order_params(&order).unwrap_err();
1887
1888 assert_eq!(
1889 error.downcast_ref::<InstrumentLookupError>(),
1890 Some(&InstrumentLookupError::not_found(instrument_id))
1891 );
1892 }
1893
1894 #[rstest]
1895 #[case(false)]
1896 #[case(true)]
1897 #[tokio::test]
1898 async fn routed_spot_rejection_precedes_submission(#[case] batch: bool) {
1899 let (mut client, _, cache) = submission_test_rig(TimeInForce::Gtc);
1900 let instrument = routed_spot_instrument();
1901 client.http_client.cache_instruments(&[instrument]);
1902
1903 let orders = (0..2)
1904 .map(|index| {
1905 let order = OrderTestBuilder::new(OrderType::Limit)
1906 .trader_id(TraderId::from("TESTER-001"))
1907 .strategy_id(StrategyId::from("S-001"))
1908 .instrument_id(InstrumentId::from("BTC_USDC.DERIBIT"))
1909 .client_order_id(ClientOrderId::new(format!("routed-{index}")))
1910 .quantity(Quantity::from("0.0042"))
1911 .price(Price::from("45000.25"))
1912 .reduce_only(!batch || index == 1)
1913 .build();
1914 cache
1915 .borrow_mut()
1916 .add_order(order.clone(), None, None, false)
1917 .unwrap();
1918 order
1919 })
1920 .collect::<Vec<_>>();
1921
1922 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
1923 client.emitter.set_sender(tx);
1924
1925 let error = submit_test_orders(&client, &orders, batch).unwrap_err();
1926
1927 assert_eq!(
1928 error.to_string(),
1929 "Deribit routed spot does not support reduce_only"
1930 );
1931 assert_eq!(client.pending_tasks.len(), 0);
1932 assert_eq!(
1933 rx.try_recv().unwrap_err(),
1934 tokio::sync::mpsc::error::TryRecvError::Empty
1935 );
1936
1937 for order in orders {
1938 assert_eq!(
1939 cache
1940 .borrow()
1941 .order(&order.client_order_id())
1942 .unwrap()
1943 .status(),
1944 OrderStatus::Initialized
1945 );
1946 }
1947 }
1948
1949 fn dispatch_test_rig() -> (
1950 ExecutionEventEmitter,
1951 tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
1952 ) {
1953 let trader_id = TraderId::from("TRADER-001");
1954 let account_id = AccountId::from("DERIBIT-001");
1955 let mut emitter = ExecutionEventEmitter::new(
1956 get_atomic_clock_realtime(),
1957 trader_id,
1958 account_id,
1959 AccountType::Margin,
1960 None,
1961 );
1962 let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
1963 emitter.set_sender(tx);
1964 (emitter, rx)
1965 }
1966
1967 #[rstest]
1968 fn test_local_command_denial_preserves_owner_and_venue_id(
1969 #[values(false, true)] modify: bool,
1970 #[values(false, true)] cached_venue: bool,
1971 ) {
1972 let (emitter, mut rx) = dispatch_test_rig();
1973 let client_order_id = ClientOrderId::from("O-LOCAL-DENIAL-017");
1974 let instrument_id = InstrumentId::from("BTC-PERPETUAL.DERIBIT");
1975 let strategy_id = StrategyId::from("OWNER-019");
1976 let account_id = AccountId::from("DERIBIT-001");
1977 let command_venue_id = VenueOrderId::from("V-COMMAND-023");
1978 let cached_venue_id = VenueOrderId::from("V-CACHED-029");
1979 let command_id = UUID4::new();
1980 let mut order = OrderTestBuilder::new(OrderType::Limit)
1981 .trader_id(TraderId::from("TRADER-001"))
1982 .strategy_id(strategy_id)
1983 .instrument_id(instrument_id)
1984 .client_order_id(client_order_id)
1985 .quantity(Quantity::from("2"))
1986 .price(Price::from("50000.0"))
1987 .build();
1988
1989 if cached_venue {
1990 let accepted = TestOrderEventStubs::accepted(&order, account_id, cached_venue_id);
1991 order.apply(accepted).unwrap();
1992 }
1993
1994 let requester = StrategyId::from("REQUESTER-031");
1995 let requested_instrument = InstrumentId::from("ETH-PERPETUAL.DERIBIT");
1996 let clock = get_atomic_clock_realtime();
1997
1998 if modify {
1999 let command = ModifyOrder::new(
2000 TraderId::from("TRADER-001"),
2001 None,
2002 requester,
2003 requested_instrument,
2004 client_order_id,
2005 Some(command_venue_id),
2006 Some(Quantity::from("3")),
2007 Some(Price::from("51000.0")),
2008 None,
2009 command_id,
2010 UnixNanos::default(),
2011 None,
2012 None,
2013 );
2014 let error = deny_modify_command(&emitter, clock, &command, "not sent", Some(&order))
2015 .unwrap_err();
2016 assert_eq!(error.to_string(), "not sent");
2017 } else {
2018 let command = CancelOrder::new(
2019 TraderId::from("TRADER-001"),
2020 None,
2021 requester,
2022 requested_instrument,
2023 client_order_id,
2024 Some(command_venue_id),
2025 command_id,
2026 UnixNanos::default(),
2027 None,
2028 None,
2029 );
2030 deny_cancel_command(&emitter, clock, &command, Some(&order), "not sent");
2031 }
2032
2033 let event = rx.try_recv().unwrap();
2034
2035 let (trader, strategy, instrument, client, venue, account, reason, cause) = match event {
2036 ExecutionEvent::Order(OrderEventAny::ModifyDenied(event)) if modify => (
2037 event.trader_id,
2038 event.strategy_id,
2039 event.instrument_id,
2040 event.client_order_id,
2041 event.venue_order_id,
2042 event.account_id,
2043 event.reason,
2044 event.causation_id,
2045 ),
2046 ExecutionEvent::Order(OrderEventAny::CancelDenied(event)) if !modify => (
2047 event.trader_id,
2048 event.strategy_id,
2049 event.instrument_id,
2050 event.client_order_id,
2051 event.venue_order_id,
2052 event.account_id,
2053 event.reason,
2054 event.causation_id,
2055 ),
2056 other => panic!("Expected matching local command denial, was {other:?}"),
2057 };
2058
2059 assert_eq!(trader, TraderId::from("TRADER-001"));
2060 assert_eq!(strategy, strategy_id);
2061 assert_eq!(instrument, instrument_id);
2062 assert_eq!(client, client_order_id);
2063 assert_eq!(
2064 venue,
2065 Some(if cached_venue {
2066 cached_venue_id
2067 } else {
2068 command_venue_id
2069 })
2070 );
2071 assert_eq!(account, Some(account_id));
2072 assert_eq!(reason, "not sent");
2073 assert_eq!(cause, Some(command_id));
2074 assert!(rx.try_recv().is_err());
2075 }
2076
2077 fn fill_report() -> FillReport {
2078 FillReport::new(
2079 AccountId::from("DERIBIT-001"),
2080 InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
2081 VenueOrderId::from("ETH-584830574"),
2082 TradeId::from("ETH-2696068"),
2083 OrderSide::Buy,
2084 Quantity::from("1.000000"),
2085 Price::from("203.80"),
2086 Money::from("0.00036801 USDT"),
2087 LiquiditySide::Taker,
2088 Some(ClientOrderId::from("O-19700101-000000-001-001-1")),
2089 None,
2090 UnixNanos::from(2),
2091 UnixNanos::from(3),
2092 None,
2093 )
2094 }
2095
2096 #[rstest]
2097 fn dispatch_tracked_fill_uses_order_event_path() {
2098 let (emitter, mut rx) = dispatch_test_rig();
2099 let report = fill_report();
2100 let filled = OrderFilled::new(
2101 TraderId::from("TRADER-001"),
2102 StrategyId::from("S-001"),
2103 report.instrument_id,
2104 report.client_order_id.unwrap(),
2105 report.venue_order_id,
2106 report.account_id,
2107 report.trade_id,
2108 report.order_side,
2109 OrderType::Market,
2110 report.last_qty,
2111 report.last_px,
2112 Currency::USDT(),
2113 report.liquidity_side,
2114 UUID4::new(),
2115 report.ts_event,
2116 report.ts_init,
2117 false,
2118 None,
2119 Some(report.commission),
2120 None,
2121 );
2122
2123 dispatch_ws_message(NautilusWsMessage::OrderFilled(filled), &emitter);
2124
2125 assert!(matches!(
2126 rx.try_recv().unwrap(),
2127 ExecutionEvent::Order(OrderEventAny::Filled(event))
2128 if event.client_order_id == ClientOrderId::from("O-19700101-000000-001-001-1")
2129 && event.trade_id == TradeId::from("ETH-2696068")
2130 ));
2131 assert!(rx.try_recv().is_err());
2132 }
2133
2134 #[rstest]
2135 fn dispatch_untracked_fill_keeps_report_path() {
2136 let (emitter, mut rx) = dispatch_test_rig();
2137 let report = fill_report();
2138
2139 dispatch_ws_message(NautilusWsMessage::FillReports(vec![report]), &emitter);
2140
2141 assert!(matches!(
2142 rx.try_recv().unwrap(),
2143 ExecutionEvent::Report(ExecutionReport::Fill(_))
2144 ));
2145 assert!(rx.try_recv().is_err());
2146 }
2147
2148 #[rstest]
2149 #[case(false, false, "Cannot send order event: sender not initialized")]
2150 #[case(false, true, "Failed to send order event: channel closed")]
2151 #[case(true, false, "Cannot send order event: sender not initialized")]
2152 #[case(true, true, "Failed to send order event: channel closed")]
2153 #[tokio::test]
2154 async fn test_submit_event_failure_returns_error_before_spawning(
2155 #[case] batch: bool,
2156 #[case] closed: bool,
2157 #[case] expected_error: &str,
2158 ) {
2159 let (mut client, orders, _cache) = submission_test_rig(TimeInForce::Gtc);
2160
2161 if closed {
2162 let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2163 client.emitter.set_sender(tx);
2164 drop(rx);
2165 }
2166
2167 let error = submit_test_orders(&client, &orders, batch).unwrap_err();
2168
2169 assert_eq!(error.to_string(), expected_error);
2170 assert_eq!(client.pending_tasks.len(), 0);
2171
2172 for order in orders {
2173 let cached = client
2174 .core
2175 .cache()
2176 .try_order_owned(&order.client_order_id())
2177 .unwrap();
2178 assert_eq!(cached.status(), OrderStatus::Initialized);
2179 }
2180 }
2181
2182 #[rstest]
2183 #[tokio::test]
2184 async fn test_submit_list_validation_failure_precedes_events_and_tasks() {
2185 let (mut client, orders, _cache) = submission_test_rig(TimeInForce::AtTheOpen);
2186 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2187 client.emitter.set_sender(tx);
2188
2189 let error = submit_test_orders(&client, &orders, true).unwrap_err();
2190
2191 assert_eq!(
2192 error.to_string(),
2193 "Unsupported time_in_force AtTheOpen for Deribit"
2194 );
2195 assert_eq!(
2196 rx.try_recv().unwrap_err(),
2197 tokio::sync::mpsc::error::TryRecvError::Empty
2198 );
2199 assert_eq!(client.pending_tasks.len(), 0);
2200 }
2201
2202 #[tokio::test]
2203 async fn unauthenticated_submit_emits_one_rejection_and_no_second_event() {
2204 let (mut client, orders, _) = submission_test_rig(TimeInForce::Gtc);
2205 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2206 client.emitter.set_sender(tx);
2207 assert!(!client.ws_client.is_authenticated());
2208
2209 submit_test_orders(&client, &orders, false).unwrap();
2210 client.await_pending_tasks().await.unwrap();
2211
2212 let submitted = rx.try_recv().expect("submitted event");
2213 let rejected = rx.try_recv().expect("rejection event");
2214 assert!(rx.try_recv().is_err());
2215
2216 let ExecutionEvent::Order(OrderEventAny::Submitted(submitted)) = submitted else {
2217 panic!("expected submitted, was {submitted:?}");
2218 };
2219
2220 let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) = rejected else {
2221 panic!("expected rejected, was {rejected:?}");
2222 };
2223
2224 assert_eq!(submitted.client_order_id, orders[0].client_order_id());
2225 assert_eq!(rejected.client_order_id, orders[0].client_order_id());
2226 assert_eq!(rejected.reason.as_str(), "not authenticated");
2227 assert!(!rejected.due_post_only);
2228 }
2229
2230 #[tokio::test]
2231 async fn shutdown_before_submit_task_emits_one_rejection() {
2232 let (mut client, orders, _) = submission_test_rig(TimeInForce::Gtc);
2233 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2234 client.emitter.set_sender(tx);
2235 client.abort_pending_tasks();
2236
2237 submit_test_orders(&client, &orders, false).unwrap();
2238
2239 let submitted = rx.try_recv().expect("submitted event");
2240 let rejected = rx.try_recv().expect("rejection event");
2241 assert!(rx.try_recv().is_err());
2242
2243 let ExecutionEvent::Order(OrderEventAny::Submitted(submitted)) = submitted else {
2244 panic!("expected submitted, was {submitted:?}");
2245 };
2246
2247 let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) = rejected else {
2248 panic!("expected rejected, was {rejected:?}");
2249 };
2250
2251 assert_eq!(submitted.client_order_id, orders[0].client_order_id());
2252 assert_eq!(rejected.client_order_id, orders[0].client_order_id());
2253 assert_eq!(rejected.reason.as_str(), REASON_NOT_STARTED);
2254 assert!(!rejected.due_post_only);
2255 assert_eq!(client.pending_tasks.len(), 0);
2256 }
2257
2258 #[tokio::test]
2259 async fn shutdown_before_submit_list_rejects_each_unsent_order() {
2260 let (mut client, orders, _) = submission_test_rig(TimeInForce::Gtc);
2261 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2262 client.emitter.set_sender(tx);
2263 client.abort_pending_tasks();
2264
2265 submit_test_orders(&client, &orders, true).unwrap();
2266
2267 let mut rejected = Vec::new();
2268
2269 while let Ok(event) = rx.try_recv() {
2270 if let ExecutionEvent::Order(OrderEventAny::Rejected(event)) = event {
2271 rejected.push(event.client_order_id);
2272 }
2273 }
2274
2275 assert_eq!(
2276 rejected,
2277 vec![orders[0].client_order_id(), orders[1].client_order_id()]
2278 );
2279 assert_eq!(client.pending_tasks.len(), 0);
2280 }
2281
2282 #[tokio::test]
2283 async fn shutdown_before_modify_emits_one_modify_denied() {
2284 let (mut client, orders, _) = submission_test_rig(TimeInForce::Gtc);
2285 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2286 client.emitter.set_sender(tx);
2287 client.abort_pending_tasks();
2288 let client_order_id = orders[0].client_order_id();
2289
2290 client
2291 .modify_order(ModifyOrder::new(
2292 orders[0].trader_id(),
2293 Some(client.client_id()),
2294 orders[0].strategy_id(),
2295 orders[0].instrument_id(),
2296 client_order_id,
2297 Some(VenueOrderId::from("DERIBIT-ORDER-1")),
2298 Some(Quantity::from("2")),
2299 Some(Price::from("51000")),
2300 None,
2301 UUID4::new(),
2302 UnixNanos::default(),
2303 None,
2304 None,
2305 ))
2306 .unwrap();
2307
2308 let event = rx.try_recv().expect("modify denied event");
2309 assert!(rx.try_recv().is_err());
2310
2311 let ExecutionEvent::Order(OrderEventAny::ModifyDenied(event)) = event else {
2312 panic!("expected modify denied, was {event:?}");
2313 };
2314
2315 assert_eq!(event.client_order_id, client_order_id);
2316 assert_eq!(
2317 event.venue_order_id,
2318 Some(VenueOrderId::from("DERIBIT-ORDER-1"))
2319 );
2320 assert_eq!(event.reason.as_str(), REASON_NOT_STARTED);
2321 }
2322
2323 #[tokio::test]
2324 async fn shutdown_before_cancel_emits_one_cancel_denied() {
2325 let (mut client, orders, _) = submission_test_rig(TimeInForce::Gtc);
2326 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2327 client.emitter.set_sender(tx);
2328 client.abort_pending_tasks();
2329 let client_order_id = orders[0].client_order_id();
2330
2331 client
2332 .cancel_order(CancelOrder::new(
2333 orders[0].trader_id(),
2334 Some(client.client_id()),
2335 orders[0].strategy_id(),
2336 orders[0].instrument_id(),
2337 client_order_id,
2338 Some(VenueOrderId::from("DERIBIT-ORDER-1")),
2339 UUID4::new(),
2340 UnixNanos::default(),
2341 None,
2342 None,
2343 ))
2344 .unwrap();
2345
2346 let event = rx.try_recv().expect("cancel denied event");
2347 assert!(rx.try_recv().is_err());
2348
2349 let ExecutionEvent::Order(OrderEventAny::CancelDenied(event)) = event else {
2350 panic!("expected cancel denied, was {event:?}");
2351 };
2352
2353 assert_eq!(event.client_order_id, client_order_id);
2354 assert_eq!(
2355 event.venue_order_id,
2356 Some(VenueOrderId::from("DERIBIT-ORDER-1"))
2357 );
2358 assert_eq!(event.reason.as_str(), REASON_NOT_STARTED);
2359 }
2360
2361 #[rstest]
2362 #[case(true)]
2363 #[case(false)]
2364 #[tokio::test]
2365 async fn unauthenticated_modify_or_cancel_emits_one_denial(#[case] modify: bool) {
2366 let (mut client, orders, _) = submission_test_rig(TimeInForce::Gtc);
2367 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2368 client.emitter.set_sender(tx);
2369 assert!(!client.ws_client.is_authenticated());
2370 let client_order_id = orders[0].client_order_id();
2371 let venue_order_id = VenueOrderId::from("DERIBIT-ORDER-1");
2372
2373 if modify {
2374 client
2375 .modify_order(ModifyOrder::new(
2376 orders[0].trader_id(),
2377 Some(client.client_id()),
2378 orders[0].strategy_id(),
2379 orders[0].instrument_id(),
2380 client_order_id,
2381 Some(venue_order_id),
2382 Some(Quantity::from("2")),
2383 Some(Price::from("51000")),
2384 None,
2385 UUID4::new(),
2386 UnixNanos::default(),
2387 None,
2388 None,
2389 ))
2390 .unwrap();
2391 } else {
2392 client
2393 .cancel_order(CancelOrder::new(
2394 orders[0].trader_id(),
2395 Some(client.client_id()),
2396 orders[0].strategy_id(),
2397 orders[0].instrument_id(),
2398 client_order_id,
2399 Some(venue_order_id),
2400 UUID4::new(),
2401 UnixNanos::default(),
2402 None,
2403 None,
2404 ))
2405 .unwrap();
2406 }
2407
2408 client.await_pending_tasks().await.unwrap();
2409 let event = rx.try_recv().expect("denial event");
2410 assert!(rx.try_recv().is_err());
2411
2412 let (kind, reason, venue) = match event {
2413 ExecutionEvent::Order(OrderEventAny::ModifyDenied(event)) if modify => {
2414 (event.client_order_id, event.reason, event.venue_order_id)
2415 }
2416 ExecutionEvent::Order(OrderEventAny::CancelDenied(event)) if !modify => {
2417 (event.client_order_id, event.reason, event.venue_order_id)
2418 }
2419 other => panic!("expected one denial, was {other:?}"),
2420 };
2421
2422 assert_eq!(kind, client_order_id);
2423 assert_eq!(reason.as_str(), "not authenticated");
2424 assert_eq!(venue, Some(venue_order_id));
2425 }
2426
2427 #[tokio::test]
2428 async fn shutdown_before_batch_cancel_emits_one_denial() {
2429 let (mut client, orders, _) = submission_test_rig(TimeInForce::Gtc);
2430 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2431 client.emitter.set_sender(tx);
2432 client.abort_pending_tasks();
2433 let client_order_id = orders[0].client_order_id();
2434 let venue_order_id = VenueOrderId::from("DERIBIT-ORDER-1");
2435
2436 client
2437 .batch_cancel_orders(BatchCancelOrders::new(
2438 orders[0].trader_id(),
2439 Some(client.client_id()),
2440 orders[0].strategy_id(),
2441 orders[0].instrument_id(),
2442 vec![CancelOrder::new(
2443 orders[0].trader_id(),
2444 Some(client.client_id()),
2445 orders[0].strategy_id(),
2446 orders[0].instrument_id(),
2447 client_order_id,
2448 Some(venue_order_id),
2449 UUID4::new(),
2450 UnixNanos::default(),
2451 None,
2452 None,
2453 )],
2454 UUID4::new(),
2455 UnixNanos::default(),
2456 None,
2457 None,
2458 ))
2459 .unwrap();
2460
2461 let event = rx.try_recv().expect("batch cancel denial");
2462 assert!(rx.try_recv().is_err());
2463
2464 let ExecutionEvent::Order(OrderEventAny::CancelDenied(event)) = event else {
2465 panic!("expected cancel denied, was {event:?}");
2466 };
2467
2468 assert_eq!(event.client_order_id, client_order_id);
2469 assert_eq!(event.venue_order_id, Some(venue_order_id));
2470 assert_eq!(event.reason.as_str(), REASON_NOT_STARTED);
2471 }
2472
2473 #[tokio::test]
2474 async fn shutdown_before_side_cancel_all_emits_one_denial() {
2475 let (mut client, orders, cache) = submission_test_rig(TimeInForce::Gtc);
2476 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2477 client.emitter.set_sender(tx);
2478 let mut order = orders[0].clone();
2479 let venue_order_id = VenueOrderId::from("DERIBIT-ORDER-1");
2480 let accepted =
2481 TestOrderEventStubs::accepted(&order, AccountId::from("DERIBIT-001"), venue_order_id);
2482 order.apply(accepted).unwrap();
2483 cache
2484 .borrow_mut()
2485 .add_order(order.clone(), None, None, true)
2486 .unwrap();
2487 client.abort_pending_tasks();
2488
2489 client
2490 .cancel_all_orders(CancelAllOrders::new(
2491 order.trader_id(),
2492 Some(client.client_id()),
2493 order.strategy_id(),
2494 order.instrument_id(),
2495 Some(order.order_side()),
2496 UUID4::new(),
2497 UnixNanos::default(),
2498 None,
2499 None,
2500 ))
2501 .unwrap();
2502
2503 let event = rx.try_recv().expect("side cancel denial");
2504 assert!(rx.try_recv().is_err());
2505
2506 let ExecutionEvent::Order(OrderEventAny::CancelDenied(event)) = event else {
2507 panic!("expected cancel denied, was {event:?}");
2508 };
2509
2510 assert_eq!(event.client_order_id, order.client_order_id());
2511 assert_eq!(event.venue_order_id, Some(venue_order_id));
2512 assert_eq!(event.reason.as_str(), REASON_NOT_STARTED);
2513 }
2514
2515 #[rstest]
2516 #[case(false, false)]
2517 #[case(true, false)]
2518 #[case(true, true)]
2519 #[tokio::test]
2520 async fn test_submit_queues_expected_events(#[case] batch: bool, #[case] close_first: bool) {
2521 let (mut client, orders, cache) = submission_test_rig(TimeInForce::Gtc);
2522 if close_first {
2523 let order = &orders[0];
2524
2525 let denied = OrderDenied::new(
2526 order.trader_id(),
2527 order.strategy_id(),
2528 order.instrument_id(),
2529 order.client_order_id(),
2530 "Already denied".into(),
2531 UUID4::new(),
2532 UnixNanos::from(1),
2533 UnixNanos::from(2),
2534 );
2535 cache
2536 .borrow_mut()
2537 .update_order(&OrderEventAny::Denied(denied))
2538 .unwrap();
2539 }
2540
2541 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
2542 client.emitter.set_sender(tx);
2543
2544 submit_test_orders(&client, &orders, batch).unwrap();
2545 let expected = if close_first {
2546 &orders[1..]
2547 } else if batch {
2548 &orders[..]
2549 } else {
2550 &orders[..1]
2551 };
2552
2553 let events = expected
2554 .iter()
2555 .map(|_| match rx.try_recv().unwrap() {
2556 ExecutionEvent::Order(OrderEventAny::Submitted(event)) => event,
2557 other => panic!("Unexpected submitted message: {other:?}"),
2558 })
2559 .collect::<Vec<_>>();
2560
2561 client.await_pending_tasks().await.unwrap();
2562 let mut rejected = Vec::new();
2563
2564 while let Ok(event) = rx.try_recv() {
2565 match event {
2566 ExecutionEvent::Order(OrderEventAny::Rejected(event)) => {
2567 assert_eq!(event.reason.as_str(), "not authenticated");
2568 rejected.push(event.client_order_id);
2569 }
2570 other => panic!("Unexpected submission result: {other:?}"),
2571 }
2572 }
2573
2574 rejected.sort();
2575 let mut expected_rejected: Vec<_> = expected.iter().map(Order::client_order_id).collect();
2576 expected_rejected.sort();
2577 assert_eq!(rejected, expected_rejected);
2578
2579 for (event, order) in events.iter().zip(expected) {
2580 assert_eq!(event.trader_id, client.core.trader_id);
2581 assert_eq!(event.strategy_id, order.strategy_id());
2582 assert_eq!(event.instrument_id, order.instrument_id());
2583 assert_eq!(event.client_order_id, order.client_order_id());
2584 assert_eq!(event.account_id, client.core.account_id);
2585 assert_eq!(event.ts_event, event.ts_init);
2586 assert_eq!(event.causation_id, None);
2587 }
2588 }
2589
2590 fn submission_test_rig(
2591 second_time_in_force: TimeInForce,
2592 ) -> (DeribitExecutionClient, Vec<OrderAny>, Rc<RefCell<Cache>>) {
2593 let cache = Rc::new(RefCell::new(Cache::default()));
2594
2595 let core = ExecutionClientCore::new(
2596 TraderId::from("TESTER-001"),
2597 ClientId::from("DERIBIT"),
2598 *DERIBIT_VENUE,
2599 OmsType::Netting,
2600 AccountId::from("DERIBIT-001"),
2601 AccountType::Margin,
2602 None,
2603 cache.clone(),
2604 );
2605
2606 let config = DeribitExecutionClientConfig {
2607 api_key: Some("test_api_key".into()),
2608 api_secret: Some("test_api_secret".into()),
2609 ..Default::default()
2610 };
2611
2612 let client = DeribitExecutionClient::new(core, config).unwrap();
2613 let response: DeribitJsonRpcResponse<Vec<DeribitInstrument>> =
2614 serde_json::from_str(include_str!("../test_data/http_get_instruments.json")).unwrap();
2615 let instrument = parse_deribit_instrument_any(
2616 &response.result.unwrap()[0],
2617 UnixNanos::default(),
2618 UnixNanos::default(),
2619 )
2620 .unwrap()
2621 .unwrap();
2622 client.http_client.cache_instruments(&[instrument]);
2623
2624 let orders = [TimeInForce::Gtc, second_time_in_force]
2625 .into_iter()
2626 .enumerate()
2627 .map(|(index, time_in_force)| {
2628 let order = OrderTestBuilder::new(OrderType::Limit)
2629 .trader_id(TraderId::from("TESTER-001"))
2630 .strategy_id(StrategyId::from("S-001"))
2631 .instrument_id(InstrumentId::from("BTC-PERPETUAL.DERIBIT"))
2632 .client_order_id(ClientOrderId::new(format!("submit-{index}")))
2633 .quantity(Quantity::from(if index == 0 { "10" } else { "20" }))
2634 .price(Price::from(if index == 0 { "50000" } else { "51000" }))
2635 .time_in_force(time_in_force)
2636 .build();
2637 cache
2638 .borrow_mut()
2639 .add_order(order.clone(), None, None, false)
2640 .unwrap();
2641 order
2642 })
2643 .collect();
2644
2645 (client, orders, cache)
2646 }
2647
2648 fn submit_test_orders(
2649 client: &DeribitExecutionClient,
2650 orders: &[OrderAny],
2651 batch: bool,
2652 ) -> anyhow::Result<()> {
2653 let first = &orders[0];
2654
2655 if batch {
2656 let order_list = OrderList::new(
2657 OrderListId::from("submit-list-001"),
2658 first.instrument_id(),
2659 first.strategy_id(),
2660 orders.iter().map(Order::client_order_id).collect(),
2661 UnixNanos::default(),
2662 );
2663 client.submit_order_list(SubmitOrderList::new(
2664 first.trader_id(),
2665 Some(client.client_id()),
2666 first.strategy_id(),
2667 order_list,
2668 orders
2669 .iter()
2670 .map(|order| order.init_event().clone())
2671 .collect(),
2672 None,
2673 None,
2674 None,
2675 UUID4::new(),
2676 UnixNanos::default(),
2677 None,
2678 ))
2679 } else {
2680 client.submit_order(SubmitOrder::new(
2681 first.trader_id(),
2682 Some(client.client_id()),
2683 first.strategy_id(),
2684 first.instrument_id(),
2685 first.client_order_id(),
2686 first.init_event().clone(),
2687 None,
2688 None,
2689 None,
2690 UUID4::new(),
2691 UnixNanos::default(),
2692 None,
2693 ))
2694 }
2695 }
2696}