Skip to main content

nautilus_deribit/
execution.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Live execution client implementation for the Deribit adapter.
17
18use 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/// Deribit live execution client.
75#[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    /// Creates a new [`DeribitExecutionClient`].
89    ///
90    /// # Errors
91    ///
92    /// Returns an error if the client fails to initialize.
93    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        // Set account ID for order/fill reports
152        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    /// Spawns an async task for execution operations.
179    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    /// Aborts all pending async tasks.
195    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    // Rejects unsupported order types, time-in-force values, and params without exact JSON numbers
250    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            // Deribit rejects `time_in_force` on market-style order types
276            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        // Deribit's `valid_until` is a REQUEST timeout, not order expiry.
301        // Deribit's `good_til_day` expires at end of trading session (8 UTC).
302        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(&params)?;
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    /// Spawns a stream handler to dispatch WebSocket messages to the execution engine.
398    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        // Check if credentials are available before requesting account state
568        if !self.config.has_api_credentials() {
569            anyhow::bail!("Missing API credentials; set Deribit environment variables");
570        }
571
572        // Set account ID for order/fill reports
573        self.ws_client.set_account_id(self.core.account_id);
574
575        self.load_execution_instruments().await?;
576
577        // Fetch initial account state
578        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            // Subscribe to user order and trade updates for all instruments
600            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                // Roll back subscription state so a retry re-sends subscribe requests
615                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            // Spawn stream handler to dispatch WebSocket messages to the execution engine
624            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        // Extract venue order ID (Deribit's order_id)
859        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        // Spawn async task to query order state via WebSocket
873        // Response will be dispatched through the WebSocket stream handler as OrderStatusReport
874        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        // Extract venue order ID (Deribit's order_id)
956        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        // Extract quantity - if not provided, get from order in cache
970        let quantity = if let Some(qty) = cmd.quantity {
971            qty
972        } else {
973            // Get order from cache to use its current quantity
974            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(&params) {
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        // Extract venue order ID (Deribit's order_id)
1095        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        // Without a side filter, use efficient bulk cancel via Deribit API
1176        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        // For specific side (Buy/Sell), filter from cache and cancel individually
1200        // Deribit API doesn't support side filtering, so we implement it locally
1201        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        // Cancel each matching order individually
1251        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        // Deribit doesn't have native batch cancel by order ID
1324        // Loop through and cancel each order individually
1325        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, // Search all orders, not just open
1444                scope,
1445            )
1446            .await?
1447            .reports;
1448
1449        // Bulk reports can omit orders outside the cached products or venue history window
1450        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    // External orders can lack a venue label after Nautilus assigns a client order ID
1459    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
1590/// Dispatches a WebSocket message using the event emitter.
1591fn 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            // Data messages are handled by the data client, not execution
1658            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
1726// Serializes the params as the handler will, so a decimal without an exact JSON number is rejected
1727// locally instead of failing after the order is submitted.
1728fn 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}