Skip to main content

nautilus_dydx/execution/
mod.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 dYdX adapter.
17//!
18//! This module provides the execution client for submitting orders, cancellations,
19//! and managing positions on dYdX v4.
20//!
21//! # Order Types
22//!
23//! dYdX supports the following order types:
24//!
25//! - **Market**: Execute immediately at best available price.
26//! - **Limit**: Execute at specified price or better.
27//! - **Stop Market**: Triggered when price crosses stop price, then executes as market order.
28//! - **Stop Limit**: Triggered when price crosses stop price, then places limit order.
29//! - **Take Profit Market**: Close position at profit target, executes as market order.
30//! - **Take Profit Limit**: Close position at profit target, places limit order.
31//!
32//! See <https://docs.dydx.xyz/concepts/trading/orders#types> for details.
33//!
34//! # Order Lifetimes
35//!
36//! Orders can be short-term (expire by block height) or long-term/stateful (expire by timestamp).
37//! Conditional orders (Stop/TakeProfit) are always stateful.
38//!
39//! See <https://docs.dydx.xyz/concepts/trading/orders#short-term-vs-long-term> for details.
40
41use std::{
42    sync::{
43        Arc,
44        atomic::{AtomicU64, Ordering},
45    },
46    time::{Duration, Instant},
47};
48
49use ahash::AHashMap;
50use anyhow::Context;
51use async_trait::async_trait;
52use dashmap::DashMap;
53use futures_util::{Stream, StreamExt, pin_mut};
54use nautilus_common::{
55    clients::ExecutionClient,
56    live::runner::get_exec_event_sender,
57    messages::execution::{
58        BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
59        GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
60        ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
61    },
62};
63use nautilus_core::{
64    DurationNanos, Params, UUID4, UnixNanos,
65    time::{AtomicTime, get_atomic_clock_realtime},
66};
67use nautilus_live::{
68    ExecutionClientCore, ExecutionEventEmitter, SocketControlFactory,
69    execution::{failure::CommandFailure, reports::retain_order_status_reports},
70    task::{TaskGroup, TaskGroupGuard},
71};
72use nautilus_model::{
73    accounts::AccountAny,
74    enums::{AccountType, OmsType, OrderStatus, OrderType, TimeInForce},
75    events::{
76        AccountState, OrderAccepted, OrderCanceled, OrderDeniedReason, OrderEventAny, OrderExpired,
77    },
78    identifiers::{
79        AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, Symbol, Venue, VenueOrderId,
80    },
81    instruments::{Instrument, InstrumentAny},
82    orders::{Order, OrderAny},
83    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
84    types::{AccountBalance, Currency, MarginBalance, Money},
85};
86use nautilus_network::retry::RetryConfig;
87use parking_lot::Mutex;
88use rust_decimal::Decimal;
89
90use crate::{
91    common::{
92        consts::DYDX_VENUE,
93        credential::{DydxCredential, credential_env_vars},
94        instrument_cache::InstrumentCache,
95        parse::nanos_to_secs_i64,
96    },
97    config::DydxAdapterConfig,
98    error::DydxError,
99    execution::{
100        broadcaster::TxBroadcaster,
101        encoder::ClientOrderIdEncoder,
102        order_builder::OrderMessageBuilder,
103        tx_manager::TransactionManager,
104        types::{LimitOrderParams, OrderContext},
105    },
106    grpc::{DydxGrpcClient, SHORT_TERM_ORDER_MAXIMUM_LIFETIME, types::ChainId},
107    http::{
108        client::DydxHttpClient,
109        parse::{
110            parse_account_state, parse_fill_report, parse_order_status_report,
111            parse_position_status_report,
112        },
113    },
114    websocket::{
115        DydxWsDispatchState, OrderIdentity,
116        client::DydxWebSocketClient,
117        enums::DydxWsOutputMessage,
118        fill_report_to_order_filled,
119        parse::{parse_ws_fill_report, parse_ws_order_report, parse_ws_position_report},
120    },
121};
122
123pub mod block_time;
124pub mod broadcaster;
125pub mod encoder;
126pub mod order_builder;
127pub mod submitter;
128pub mod tx_manager;
129pub mod types;
130pub mod wallet;
131
132use block_time::BlockTimeMonitor;
133
134const DYDX_INDEXER_REPORT_LIMIT: u32 = 1_000;
135
136/// Live execution client for the dYdX v4 exchange adapter.
137///
138/// Supports Market, Limit, Stop Market, Stop Limit, Take Profit Market (MarketIfTouched),
139/// and Take Profit Limit (LimitIfTouched) orders via gRPC. Trailing stops are NOT supported
140/// by the dYdX v4 protocol. dYdX requires u32 client IDs - strings are hashed to fit.
141///
142/// # Architecture
143///
144/// The client follows a two-layer execution model:
145/// 1. **Synchronous validation** - Immediate checks and event generation.
146/// 2. **Async submission** - Non-blocking gRPC calls via `TransactionManager`, `TxBroadcaster`, and `OrderMessageBuilder`.
147#[derive(Debug)]
148pub struct DydxExecutionClient {
149    core: ExecutionClientCore,
150    clock: &'static AtomicTime,
151    config: DydxAdapterConfig,
152    emitter: ExecutionEventEmitter,
153    http_client: DydxHttpClient,
154    ws_client: DydxWebSocketClient,
155    grpc_client: Arc<tokio::sync::RwLock<Option<DydxGrpcClient>>>,
156    instrument_cache: Arc<InstrumentCache>,
157    block_time_monitor: Arc<BlockTimeMonitor>,
158    oracle_prices: Arc<DashMap<InstrumentId, Decimal>>,
159    encoder: Arc<ClientOrderIdEncoder>,
160    dispatch_state: Arc<DydxWsDispatchState>,
161    order_contexts: Arc<DashMap<u32, OrderContext>>,
162    order_id_map: Arc<DashMap<String, (u32, u32)>>,
163    wallet_address: String,
164    subaccount_number: u32,
165    tx_manager: Option<Arc<TransactionManager>>,
166    broadcaster: Option<Arc<TxBroadcaster>>,
167    order_builder: Option<Arc<OrderMessageBuilder>>,
168    session_tasks: TaskGroup,
169    pending_tasks: TaskGroup,
170    shutdown_errors: Vec<String>,
171    pending_task_labels: Arc<Mutex<AHashMap<u64, &'static str>>>,
172    next_pending_task_id: AtomicU64,
173}
174
175impl DydxExecutionClient {
176    /// Creates a new [`DydxExecutionClient`].
177    ///
178    /// # Errors
179    ///
180    /// Returns an error if credentials are not found or client fails to construct.
181    pub fn new(
182        core: ExecutionClientCore,
183        config: DydxAdapterConfig,
184        wallet_address: String,
185        subaccount_number: u32,
186    ) -> anyhow::Result<Self> {
187        config.validate()?;
188
189        let trader_id = core.trader_id;
190        let account_id = core.account_id;
191        let clock = get_atomic_clock_realtime();
192        let emitter =
193            ExecutionEventEmitter::new(clock, trader_id, account_id, AccountType::Margin, None);
194
195        let retry_config = RetryConfig {
196            max_retries: config.max_retries,
197            initial_delay_ms: config.retry_delay_initial_ms,
198            max_delay_ms: config.retry_delay_max_ms,
199            ..Default::default()
200        };
201        let http_client = DydxHttpClient::new(
202            Some(config.base_url.clone()),
203            config.timeout_secs,
204            config
205                .proxy_url
206                .as_ref()
207                .map(|value| value.expose_secret().to_owned()),
208            config.network,
209            Some(retry_config),
210        )?;
211
212        let instrument_cache = http_client.instrument_cache().clone();
213
214        let credential = DydxCredential::resolve(
215            config
216                .private_key
217                .as_ref()
218                .map(|value| value.expose_secret()),
219            config.network,
220            config.authenticator_ids.clone(),
221        )?
222        .ok_or_else(|| anyhow::anyhow!("Credentials required for execution client"))?;
223
224        let ws_client = DydxWebSocketClient::new_private_with_cache(
225            config.ws_url.clone(),
226            credential,
227            core.account_id,
228            instrument_cache.clone(),
229            Some(20),
230            config.transport_backend,
231            config
232                .proxy_url
233                .as_ref()
234                .map(|value| value.expose_secret().to_owned()),
235        )
236        .with_socket_factory(SocketControlFactory::new(core.client_id, Some(*DYDX_VENUE)));
237
238        let grpc_client = Arc::new(tokio::sync::RwLock::new(None));
239
240        let session_tasks = TaskGroup::new();
241        let pending_tasks = TaskGroup::new();
242
243        Ok(Self {
244            core,
245            clock,
246            config,
247            emitter,
248            http_client,
249            ws_client,
250            grpc_client,
251            instrument_cache,
252            block_time_monitor: Arc::new(BlockTimeMonitor::new()),
253            oracle_prices: Arc::new(DashMap::new()),
254            encoder: Arc::new(ClientOrderIdEncoder::new()),
255            dispatch_state: Arc::new(DydxWsDispatchState::default()),
256            order_contexts: Arc::new(DashMap::new()),
257            order_id_map: Arc::new(DashMap::new()),
258            wallet_address,
259            subaccount_number,
260            tx_manager: None,
261            broadcaster: None,
262            order_builder: None,
263            session_tasks,
264            pending_tasks,
265            shutdown_errors: Vec::new(),
266            pending_task_labels: Arc::new(Mutex::new(AHashMap::new())),
267            next_pending_task_id: AtomicU64::new(0),
268        })
269    }
270
271    fn resolve_private_key(config: &DydxAdapterConfig) -> anyhow::Result<String> {
272        let (private_key_env, _) = credential_env_vars(config.network);
273
274        if let Some(ref pk) = config.private_key
275            && !pk.expose_secret().trim().is_empty()
276        {
277            return Ok(pk.expose_secret().to_owned());
278        }
279
280        if let Some(pk) = std::env::var(private_key_env)
281            .ok()
282            .filter(|s| !s.trim().is_empty())
283        {
284            return Ok(pk);
285        }
286
287        anyhow::bail!("{private_key_env} not found in config or environment")
288    }
289
290    fn register_order_context(&self, client_id_u32: u32, context: OrderContext) {
291        self.order_contexts.insert(client_id_u32, context);
292    }
293
294    fn get_order_context(&self, client_id_u32: u32) -> Option<OrderContext> {
295        self.order_contexts
296            .get(&client_id_u32)
297            .map(|r| r.value().clone())
298    }
299
300    fn get_chain_id(&self) -> ChainId {
301        self.config.get_chain_id()
302    }
303
304    fn spawn_ws_stream_handler(
305        &self,
306        stream: impl Stream<Item = DydxWsOutputMessage> + Send + 'static,
307    ) -> anyhow::Result<()> {
308        if !self.session_tasks.is_empty() {
309            anyhow::bail!("dYdX WebSocket stream task is already registered");
310        }
311
312        log::debug!("Starting execution WebSocket message processing task");
313
314        let trader_id = self.core.trader_id;
315        let account_id = self.core.account_id;
316        let instrument_cache = self.instrument_cache.clone();
317        let oracle_prices = self.oracle_prices.clone();
318        let encoder = self.encoder.clone();
319        let order_contexts = self.order_contexts.clone();
320        let order_id_map = self.order_id_map.clone();
321        let dispatch_state = self.dispatch_state.clone();
322        let block_time_monitor = self.block_time_monitor.clone();
323        let emitter = self.emitter.clone();
324        let clock = self.clock;
325
326        let future = async move {
327            log::debug!("Execution WebSocket message loop started");
328
329            let mut cum_fill_totals: AHashMap<VenueOrderId, (Decimal, Decimal)> = AHashMap::new();
330
331            pin_mut!(stream);
332            while let Some(msg) = stream.next().await {
333                match msg {
334                    DydxWsOutputMessage::SubaccountSubscribed(msg) => {
335                        log::debug!("Parsing subaccount subscription with full context");
336
337                        let inst_map = instrument_cache.to_instrument_id_map();
338
339                        let oracle_map: std::collections::HashMap<_, _> = oracle_prices
340                            .iter()
341                            .map(|entry| (*entry.key(), *entry.value()))
342                            .collect();
343
344                        let ts_init = clock.get_time_ns();
345                        let ts_event = ts_init;
346
347                        if let Some(ref subaccount) = msg.contents.subaccount {
348                            match parse_account_state(
349                                subaccount,
350                                account_id,
351                                &inst_map,
352                                &oracle_map,
353                                ts_event,
354                                ts_init,
355                            ) {
356                                Ok(account_state) => {
357                                    log::debug!(
358                                        "Parsed account state: {} balance(s), {} margin(s)",
359                                        account_state.balances.len(),
360                                        account_state.margins.len()
361                                    );
362                                    emitter.send_account_state(account_state);
363                                }
364                                Err(e) => {
365                                    log::error!("Failed to parse account state: {e}");
366                                }
367                            }
368
369                            if let Some(ref positions) = subaccount.open_perpetual_positions {
370                                log::debug!(
371                                    "Parsing {} position(s) from subscription",
372                                    positions.len()
373                                );
374
375                                for (market, ws_position) in positions {
376                                    match parse_ws_position_report(
377                                        ws_position,
378                                        &instrument_cache,
379                                        account_id,
380                                        ts_init,
381                                    ) {
382                                        Ok(report) => {
383                                            log::debug!(
384                                                "Parsed position report: {} {} {} {}",
385                                                report.instrument_id,
386                                                report.position_side,
387                                                report.quantity,
388                                                market
389                                            );
390                                            emitter.send_position_report(report);
391                                        }
392                                        Err(e) => {
393                                            log::error!(
394                                                "Failed to parse WebSocket position for {market}: {e}"
395                                            );
396                                        }
397                                    }
398                                }
399                            }
400                        } else {
401                            log::warn!(
402                                "Subaccount subscription without initial state (new/empty subaccount)"
403                            );
404
405                            let currency =
406                                Currency::get_or_create_crypto_with_context("USDC", None);
407                            let zero = Money::zero(currency);
408                            let balance = AccountBalance::new_checked(zero, zero, zero)
409                                .expect("zero balance should always be valid");
410                            let account_state = AccountState::new(
411                                account_id,
412                                AccountType::Margin,
413                                vec![balance],
414                                vec![],
415                                true,
416                                UUID4::new(),
417                                ts_init,
418                                ts_init,
419                                None,
420                            );
421                            emitter.send_account_state(account_state);
422                        }
423                    }
424                    DydxWsOutputMessage::SubaccountsChannelData(data) => {
425                        log::debug!(
426                            "Processing subaccounts channel data (orders={:?}, fills={:?})",
427                            data.contents.orders.as_ref().map(|o| o.len()),
428                            data.contents.fills.as_ref().map(|f| f.len())
429                        );
430                        let ts_init = clock.get_time_ns();
431
432                        let mut terminal_orders: Vec<(u32, u32, String)> = Vec::new();
433                        let mut pending_order_reports = Vec::new();
434
435                        if let Some(ref orders) = data.contents.orders {
436                            for ws_order in orders {
437                                log::debug!(
438                                    "Parsing WS order: clob_pair_id={}, status={:?}, client_id={}",
439                                    ws_order.clob_pair_id,
440                                    ws_order.status,
441                                    ws_order.client_id
442                                );
443
444                                if let Ok(client_id_u32) = ws_order.client_id.parse::<u32>() {
445                                    let client_meta = ws_order
446                                        .client_metadata
447                                        .as_ref()
448                                        .and_then(|s| s.parse::<u32>().ok())
449                                        .unwrap_or(crate::grpc::DEFAULT_RUST_CLIENT_METADATA);
450                                    order_id_map
451                                        .insert(ws_order.id.clone(), (client_id_u32, client_meta));
452                                }
453
454                                match parse_ws_order_report(
455                                    ws_order,
456                                    &instrument_cache,
457                                    &order_contexts,
458                                    &encoder,
459                                    account_id,
460                                    ts_init,
461                                ) {
462                                    Ok(report) => {
463                                        if report.order_status.is_closed()
464                                            && let Ok(cid) = ws_order.client_id.parse::<u32>()
465                                        {
466                                            let meta = ws_order
467                                                .client_metadata
468                                                .as_ref()
469                                                .and_then(|s| s.parse::<u32>().ok())
470                                                .unwrap_or(
471                                                    crate::grpc::DEFAULT_RUST_CLIENT_METADATA,
472                                                );
473                                            terminal_orders.push((cid, meta, ws_order.id.clone()));
474                                        }
475                                        let order_side = report
476                                            .order_side
477                                            .as_ref()
478                                            .map_or("NO_ORDER_SIDE", AsRef::as_ref);
479                                        log::debug!(
480                                            "Parsed order report: {} {} {:?} qty={} client_order_id={:?}",
481                                            report.instrument_id,
482                                            order_side,
483                                            report.order_status,
484                                            report.quantity,
485                                            report.client_order_id
486                                        );
487                                        pending_order_reports.push(report);
488                                    }
489                                    Err(e) => {
490                                        log::error!("Failed to parse WebSocket order: {e}");
491                                    }
492                                }
493                            }
494                        }
495
496                        // Emit fills before order status for correct reconciliation
497                        if let Some(ref fills) = data.contents.fills {
498                            for ws_fill in fills {
499                                match parse_ws_fill_report(
500                                    ws_fill,
501                                    &instrument_cache,
502                                    &order_id_map,
503                                    &order_contexts,
504                                    &encoder,
505                                    account_id,
506                                    ts_init,
507                                ) {
508                                    Ok(report) => {
509                                        log::debug!(
510                                            "Parsed fill report: {} {} {} @ {} client_order_id={:?}",
511                                            report.instrument_id,
512                                            report.venue_order_id,
513                                            report.last_qty,
514                                            report.last_px,
515                                            report.client_order_id
516                                        );
517
518                                        let identity = report.client_order_id.and_then(|cid| {
519                                            dispatch_state
520                                                .order_identities
521                                                .get(&cid)
522                                                .map(|r| (cid, r.clone()))
523                                        });
524
525                                        if let Some((cid, ident)) = identity {
526                                            if !dispatch_state.emitted_accepted.contains(&cid) {
527                                                dispatch_state.insert_accepted(cid);
528                                                let accepted = OrderAccepted::new(
529                                                    trader_id,
530                                                    ident.strategy_id,
531                                                    ident.instrument_id,
532                                                    cid,
533                                                    report.venue_order_id,
534                                                    account_id,
535                                                    UUID4::new(),
536                                                    ts_init,
537                                                    ts_init,
538                                                    false,
539                                                );
540                                                emitter.send_order_event(OrderEventAny::Accepted(
541                                                    accepted,
542                                                ));
543                                            }
544
545                                            dispatch_state.insert_filled(cid);
546                                            let instrument =
547                                                instrument_cache.get(&report.instrument_id);
548                                            let quote_currency = instrument
549                                                .map_or_else(Currency::USD, |i: InstrumentAny| {
550                                                    i.quote_currency()
551                                                });
552                                            let filled = fill_report_to_order_filled(
553                                                &report,
554                                                trader_id,
555                                                &ident,
556                                                quote_currency,
557                                            );
558                                            emitter.send_order_event(OrderEventAny::Filled(filled));
559                                        } else {
560                                            let entry = cum_fill_totals
561                                                .entry(report.venue_order_id)
562                                                .or_default();
563                                            let qty = report.last_qty.as_decimal();
564                                            entry.0 += report.last_px.as_decimal() * qty;
565                                            entry.1 += qty;
566                                            emitter.send_fill_report(report);
567                                        }
568                                    }
569                                    Err(e) => {
570                                        log::error!("Failed to parse WebSocket fill: {e}");
571                                    }
572                                }
573                            }
574                        }
575
576                        for report in &mut pending_order_reports {
577                            if let Some((notional, total_qty)) =
578                                cum_fill_totals.get(&report.venue_order_id)
579                                && !total_qty.is_zero()
580                            {
581                                report.avg_px = Some(notional / total_qty);
582                            }
583                        }
584
585                        for report in pending_order_reports {
586                            let identity = report.client_order_id.and_then(|cid| {
587                                dispatch_state
588                                    .order_identities
589                                    .get(&cid)
590                                    .map(|r| (cid, r.clone()))
591                            });
592
593                            if let Some((cid, ident)) = identity {
594                                match report.order_status {
595                                    OrderStatus::Accepted => {
596                                        if dispatch_state.emitted_accepted.contains(&cid)
597                                            || dispatch_state.filled_orders.contains(&cid)
598                                        {
599                                            log::debug!("Skipping duplicate Accepted for {cid}");
600                                            continue;
601                                        }
602                                        dispatch_state.insert_accepted(cid);
603                                        let accepted = OrderAccepted::new(
604                                            trader_id,
605                                            ident.strategy_id,
606                                            ident.instrument_id,
607                                            cid,
608                                            report.venue_order_id,
609                                            account_id,
610                                            UUID4::new(),
611                                            report.ts_last,
612                                            ts_init,
613                                            false,
614                                        );
615                                        emitter.send_order_event(OrderEventAny::Accepted(accepted));
616                                    }
617                                    OrderStatus::Canceled => {
618                                        if !dispatch_state.emitted_accepted.contains(&cid) {
619                                            dispatch_state.insert_accepted(cid);
620                                            let accepted = OrderAccepted::new(
621                                                trader_id,
622                                                ident.strategy_id,
623                                                ident.instrument_id,
624                                                cid,
625                                                report.venue_order_id,
626                                                account_id,
627                                                UUID4::new(),
628                                                ts_init,
629                                                ts_init,
630                                                false,
631                                            );
632                                            emitter.send_order_event(OrderEventAny::Accepted(
633                                                accepted,
634                                            ));
635                                        }
636                                        // Map venue cancel-on-expiry to OrderExpired
637                                        // (dYdX reports GTD expiry as a cancel event).
638                                        let is_expiry = report
639                                            .expire_time
640                                            .is_some_and(|exp| report.ts_last >= exp);
641
642                                        if is_expiry {
643                                            let expired = OrderExpired::new(
644                                                trader_id,
645                                                ident.strategy_id,
646                                                ident.instrument_id,
647                                                cid,
648                                                UUID4::new(),
649                                                report.ts_last,
650                                                ts_init,
651                                                false,
652                                                Some(report.venue_order_id),
653                                                Some(account_id),
654                                            );
655                                            emitter
656                                                .send_order_event(OrderEventAny::Expired(expired));
657                                        } else {
658                                            let canceled = OrderCanceled::new(
659                                                trader_id,
660                                                ident.strategy_id,
661                                                ident.instrument_id,
662                                                cid,
663                                                UUID4::new(),
664                                                report.ts_last,
665                                                ts_init,
666                                                false,
667                                                Some(report.venue_order_id),
668                                                Some(account_id),
669                                                None,
670                                            );
671                                            emitter.send_order_event(OrderEventAny::Canceled(
672                                                canceled,
673                                            ));
674                                        }
675                                        dispatch_state.cleanup_terminal(&cid);
676                                    }
677                                    OrderStatus::Filled => {
678                                        // Fills are emitted before the order status
679                                        dispatch_state.cleanup_terminal(&cid);
680                                    }
681                                    OrderStatus::Expired => {
682                                        // Reached when the parser reclassifies a venue
683                                        // cancel-on-expiry to `Expired` (HTTP path) or
684                                        // when the venue reports `Expired` directly. Mirror
685                                        // the Canceled arm's Accepted-synthesis so the
686                                        // strategy sees a complete lifecycle.
687                                        if !dispatch_state.emitted_accepted.contains(&cid) {
688                                            dispatch_state.insert_accepted(cid);
689                                            let accepted = OrderAccepted::new(
690                                                trader_id,
691                                                ident.strategy_id,
692                                                ident.instrument_id,
693                                                cid,
694                                                report.venue_order_id,
695                                                account_id,
696                                                UUID4::new(),
697                                                ts_init,
698                                                ts_init,
699                                                false,
700                                            );
701                                            emitter.send_order_event(OrderEventAny::Accepted(
702                                                accepted,
703                                            ));
704                                        }
705                                        let expired = OrderExpired::new(
706                                            trader_id,
707                                            ident.strategy_id,
708                                            ident.instrument_id,
709                                            cid,
710                                            UUID4::new(),
711                                            report.ts_last,
712                                            ts_init,
713                                            false,
714                                            Some(report.venue_order_id),
715                                            Some(account_id),
716                                        );
717                                        emitter.send_order_event(OrderEventAny::Expired(expired));
718                                        dispatch_state.cleanup_terminal(&cid);
719                                    }
720                                    _ => {
721                                        emitter.send_order_status_report(report);
722                                    }
723                                }
724                            } else {
725                                emitter.send_order_status_report(report);
726                            }
727                        }
728
729                        for (client_id, client_metadata, order_id) in terminal_orders {
730                            order_contexts.remove(&client_id);
731                            encoder.remove(client_id, client_metadata);
732                            order_id_map.remove(&order_id);
733                            cum_fill_totals.remove(&VenueOrderId::new(&order_id));
734                        }
735                    }
736                    DydxWsOutputMessage::Markets(contents) => {
737                        if let Some(ref oracle_map) = contents.oracle_prices {
738                            for (symbol_str, oracle_market) in oracle_map {
739                                let instrument_id = {
740                                    let symbol = format!("{symbol_str}-PERP");
741                                    InstrumentId::new(
742                                        Symbol::new(&symbol),
743                                        *crate::common::consts::DYDX_VENUE,
744                                    )
745                                };
746
747                                if instrument_cache.get(&instrument_id).is_some()
748                                    && let Ok(price_dec) =
749                                        oracle_market.oracle_price.parse::<Decimal>()
750                                {
751                                    oracle_prices.insert(instrument_id, price_dec);
752                                    log::trace!(
753                                        "Updated oracle price for {instrument_id}: {price_dec}"
754                                    );
755                                }
756                            }
757                        }
758
759                        if let Some(ref markets) = contents.markets {
760                            for (symbol_str, market_data) in markets {
761                                if let Some(oracle_price_str) = &market_data.oracle_price {
762                                    let instrument_id = {
763                                        let symbol = format!("{symbol_str}-PERP");
764                                        InstrumentId::new(
765                                            Symbol::new(&symbol),
766                                            *crate::common::consts::DYDX_VENUE,
767                                        )
768                                    };
769
770                                    if instrument_cache.get(&instrument_id).is_some()
771                                        && let Ok(price_dec) = oracle_price_str.parse::<Decimal>()
772                                    {
773                                        oracle_prices.insert(instrument_id, price_dec);
774                                    }
775                                }
776                            }
777                        }
778                    }
779                    DydxWsOutputMessage::BlockHeight { height, time } => {
780                        log::debug!("Block height update: {height} at {time}");
781                        block_time_monitor.record_block(height, time);
782                    }
783                    DydxWsOutputMessage::Error(err) => {
784                        log::warn!("WebSocket error: {err:?}");
785                    }
786                    DydxWsOutputMessage::Reconnected { .. } => {
787                        log::info!("WebSocket reconnected");
788                    }
789                    _ => {}
790                }
791            }
792            log::debug!("WebSocket message processing task ended");
793        };
794
795        self.session_tasks
796            .spawn(future)
797            .context("failed to register dYdX execution WebSocket stream task")?;
798        log::debug!("WebSocket stream handler started");
799        Ok(())
800    }
801
802    fn mark_instruments_initialized(&self) {
803        let count = self.instrument_cache.len();
804        self.core.set_instruments_initialized();
805        log::debug!("Instruments initialized: {count} instruments in shared cache");
806    }
807
808    fn get_instrument_by_market(&self, market: &str) -> Option<InstrumentAny> {
809        self.instrument_cache.get_by_market(market)
810    }
811
812    fn get_instrument_by_clob_pair_id(&self, clob_pair_id: u32) -> Option<InstrumentAny> {
813        let instrument = self.instrument_cache.get_by_clob_id(clob_pair_id);
814
815        if instrument.is_none() {
816            self.instrument_cache.log_missing_clob_pair_id(clob_pair_id);
817        }
818
819        instrument
820    }
821
822    fn get_execution_components(
823        &self,
824    ) -> anyhow::Result<(
825        Arc<TransactionManager>,
826        Arc<TxBroadcaster>,
827        Arc<OrderMessageBuilder>,
828    )> {
829        let tx_manager = self
830            .tx_manager
831            .as_ref()
832            .ok_or_else(|| {
833                anyhow::anyhow!("TransactionManager not initialized - call connect() first")
834            })?
835            .clone();
836        let broadcaster = self
837            .broadcaster
838            .as_ref()
839            .ok_or_else(|| anyhow::anyhow!("TxBroadcaster not initialized - call connect() first"))?
840            .clone();
841        let order_builder = self
842            .order_builder
843            .as_ref()
844            .ok_or_else(|| {
845                anyhow::anyhow!("OrderMessageBuilder not initialized - call connect() first")
846            })?
847            .clone();
848        Ok((tx_manager, broadcaster, order_builder))
849    }
850
851    fn spawn_task<F>(&self, label: &'static str, fut: F)
852    where
853        F: Future<Output = anyhow::Result<()>> + Send + 'static,
854    {
855        let future = async move {
856            if let Err(e) = fut.await {
857                log::error!("{label}: {e:?}");
858            }
859        };
860
861        self.spawn_labeled(label, future);
862    }
863
864    // Generates an `OrderRejected` only for a definitive CheckTx rejection; other
865    // failures remain in flight for reconciliation
866    fn spawn_order_task<F>(
867        &self,
868        label: &'static str,
869        strategy_id: StrategyId,
870        instrument_id: InstrumentId,
871        client_order_id: ClientOrderId,
872        fut: F,
873    ) where
874        F: Future<Output = anyhow::Result<()>> + Send + 'static,
875    {
876        let emitter = self.emitter.clone();
877        let clock = self.clock;
878
879        let future = async move {
880            if let Err(e) = fut.await {
881                if is_definitive_broadcast_rejection(&e) {
882                    let error_msg = format!("{label} failed: {e:?}");
883                    log::warn!("{error_msg}");
884
885                    let ts_event = clock.get_time_ns();
886                    emitter.emit_order_rejected_event(
887                        strategy_id,
888                        instrument_id,
889                        client_order_id,
890                        &error_msg,
891                        ts_event,
892                        false,
893                    );
894                } else {
895                    log::warn!(
896                        "Ambiguous dYdX {label} failure for {client_order_id}, awaiting reconciliation: {e:?}"
897                    );
898                }
899            }
900        };
901
902        self.spawn_labeled(label, future);
903    }
904
905    fn spawn_labeled<F>(&self, label: &'static str, future: F)
906    where
907        F: Future<Output = ()> + Send + 'static,
908    {
909        let id = self.next_pending_task_id.fetch_add(1, Ordering::Relaxed);
910        self.pending_task_labels.lock().insert(id, label);
911
912        let label_guard = PendingTaskLabel {
913            id,
914            labels: Arc::clone(&self.pending_task_labels),
915        };
916        let wrapped = async move {
917            let _label = label_guard;
918            future.await;
919        };
920
921        if let Err(e) = self.pending_tasks.spawn(wrapped) {
922            self.pending_task_labels.lock().remove(&id);
923            log::warn!("Skipping dYdX {label} after shutdown began: {e}");
924        }
925    }
926
927    fn begin_pending_shutdown(&self) {
928        let labels = self.pending_task_labels.lock();
929        let pending_cancels = labels
930            .values()
931            .filter(|label| label.contains("cancel"))
932            .count();
933        let pending_other = labels.len() - pending_cancels;
934
935        if pending_cancels > 0 {
936            log::warn!(
937                "Waiting for {pending_cancels} in-flight cancel task(s) before disconnect; orders may still be open on the venue"
938            );
939        }
940
941        if pending_other > 0 {
942            log::debug!("Waiting for {pending_other} other in-flight task(s) before disconnect");
943        }
944        drop(labels);
945
946        self.pending_tasks.begin_shutdown();
947    }
948
949    async fn finish_tasks(&self) -> anyhow::Result<()> {
950        let (session_result, pending_result) = tokio::join!(
951            self.session_tasks
952                .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2)),
953            self.pending_tasks
954                .finish_shutdown(Duration::from_secs(2), Duration::from_secs(2)),
955        );
956        session_result.context("failed to finish dYdX execution session tasks")?;
957        pending_result.context("failed to finish dYdX execution command tasks")?;
958        Ok(())
959    }
960
961    async fn prepare_task_groups(&mut self) -> anyhow::Result<()> {
962        if !self.session_tasks.is_open() || !self.pending_tasks.is_open() {
963            self.session_tasks.begin_shutdown();
964            self.begin_pending_shutdown();
965            self.ws_client.begin_shutdown();
966            self.finish_shutdown().await?;
967            self.session_tasks
968                .start_generation()
969                .context("failed to start dYdX execution session task generation")?;
970            self.pending_tasks
971                .start_generation()
972                .context("failed to start dYdX execution command task generation")?;
973        }
974        Ok(())
975    }
976
977    async fn finish_shutdown(&mut self) -> anyhow::Result<()> {
978        if let Err(e) = self
979            .ws_client
980            .disconnect()
981            .await
982            .context("failed to disconnect dYdX websocket")
983        {
984            self.shutdown_errors.push(e.to_string());
985        }
986
987        if let Err(e) = self.finish_tasks().await {
988            self.shutdown_errors.push(e.to_string());
989        }
990
991        if !self.shutdown_errors.is_empty() {
992            anyhow::bail!(std::mem::take(&mut self.shutdown_errors).join("; "));
993        }
994        Ok(())
995    }
996
997    async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
998        self.begin_pending_shutdown();
999        self.session_tasks.begin_shutdown();
1000        self.ws_client.begin_shutdown();
1001        let shutdown_result = self.finish_shutdown().await;
1002        self.core.set_disconnected();
1003        shutdown_result
1004    }
1005
1006    fn send_modify_denied(
1007        &self,
1008        strategy_id: StrategyId,
1009        instrument_id: InstrumentId,
1010        client_order_id: ClientOrderId,
1011        venue_order_id: Option<VenueOrderId>,
1012        reason: &str,
1013        causation_id: UUID4,
1014    ) {
1015        let ts_event = self.clock.get_time_ns();
1016        self.emitter.emit_order_modify_denied_event(
1017            strategy_id,
1018            instrument_id,
1019            client_order_id,
1020            venue_order_id,
1021            reason,
1022            ts_event,
1023            Some(causation_id),
1024        );
1025    }
1026
1027    async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
1028        let account_id = self.core.account_id;
1029
1030        if self.core.cache().account(&account_id).is_some() {
1031            log::info!("Account {account_id} registered");
1032            return Ok(());
1033        }
1034
1035        let start = Instant::now();
1036        let timeout = Duration::from_secs_f64(timeout_secs);
1037        let interval = Duration::from_millis(10);
1038
1039        loop {
1040            tokio::time::sleep(interval).await;
1041
1042            if self.core.cache().account(&account_id).is_some() {
1043                log::info!("Account {account_id} registered");
1044                return Ok(());
1045            }
1046
1047            if start.elapsed() >= timeout {
1048                anyhow::bail!(
1049                    "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
1050                );
1051            }
1052        }
1053    }
1054}
1055
1056/// Broadcasts cancel orders with optimal partitioned strategy.
1057///
1058/// Partitions orders into short-term and long-term/conditional groups:
1059/// - Short-term -> single `MsgBatchCancel` via `broadcast_short_term()`
1060/// - Long-term/conditional -> batched `MsgCancelOrder` via `broadcast_with_retry()`
1061///
1062/// At most 2 gRPC calls regardless of order count or mix.
1063async fn broadcast_partitioned_cancels(
1064    orders: Vec<DydxCancelOrderRequest>,
1065    block_height: u32,
1066    tx_manager: Arc<TransactionManager>,
1067    broadcaster: Arc<TxBroadcaster>,
1068    order_builder: Arc<OrderMessageBuilder>,
1069    emitter: ExecutionEventEmitter,
1070    clock: &'static AtomicTime,
1071) -> anyhow::Result<()> {
1072    if orders.is_empty() {
1073        return Ok(());
1074    }
1075
1076    let (short_term_orders, long_term_orders): (Vec<_>, Vec<_>) = orders
1077        .into_iter()
1078        .partition(|order| order.order_flags == types::ORDER_FLAG_SHORT_TERM);
1079
1080    let mut errors = Vec::new();
1081
1082    if !short_term_orders.is_empty() {
1083        let st_pairs: Vec<_> = short_term_orders
1084            .iter()
1085            .map(|order| (order.instrument_id, order.client_id))
1086            .collect();
1087
1088        log::debug!(
1089            "Batch cancelling {} short-term orders with MsgBatchCancel",
1090            st_pairs.len()
1091        );
1092
1093        match order_builder.build_batch_cancel_short_term(&st_pairs, block_height) {
1094            Ok(msg) => {
1095                let operation = format!("BatchCancel {} short-term orders", st_pairs.len());
1096                match broadcaster
1097                    .broadcast_short_term(&tx_manager, vec![msg], &operation)
1098                    .await
1099                {
1100                    Ok(tx_hash) => {
1101                        log::debug!(
1102                            "Successfully batch cancelled {} short-term orders, tx_hash: {}",
1103                            st_pairs.len(),
1104                            tx_hash
1105                        );
1106                    }
1107                    Err(e) => {
1108                        let msg = format!("Short-term batch cancel failed: {e:?}");
1109                        log::warn!("{msg}");
1110
1111                        // A CheckTx rejection refuses the whole transaction
1112                        // atomically: a venue result for every cancel in it.
1113                        if e.is_definitive_broadcast_rejection() {
1114                            emit_partitioned_cancel_failure(
1115                                &short_term_orders,
1116                                &emitter,
1117                                clock,
1118                                &CommandFailure::venue_rejected(&msg),
1119                            );
1120                        }
1121                        errors.push(msg);
1122                    }
1123                }
1124            }
1125            Err(e) => {
1126                let msg = format!("Failed to build MsgBatchCancel: {e:?}");
1127                log::error!("{msg}");
1128                emit_partitioned_cancel_failure(
1129                    &short_term_orders,
1130                    &emitter,
1131                    clock,
1132                    &CommandFailure::not_sent(&msg),
1133                );
1134                errors.push(msg);
1135            }
1136        }
1137    }
1138
1139    if !long_term_orders.is_empty() {
1140        let lt_tuples: Vec<_> = long_term_orders
1141            .iter()
1142            .map(|order| (order.instrument_id, order.client_id, order.order_flags))
1143            .collect();
1144
1145        log::debug!(
1146            "Batch cancelling {} long-term orders",
1147            long_term_orders.len(),
1148        );
1149
1150        match order_builder.build_cancel_orders_batch_with_flags(&lt_tuples, block_height) {
1151            Ok(cancel_msgs) => {
1152                let operation = format!("BatchCancel {} long-term orders", long_term_orders.len());
1153                match broadcaster
1154                    .broadcast_with_retry(&tx_manager, cancel_msgs, &operation)
1155                    .await
1156                {
1157                    Ok(tx_hash) => {
1158                        log::debug!(
1159                            "Successfully batch cancelled {} long-term orders, tx_hash: {}",
1160                            long_term_orders.len(),
1161                            tx_hash
1162                        );
1163                    }
1164                    Err(e) => {
1165                        let msg = format!("Long-term batch cancel failed: {e:?}");
1166                        log::warn!("{msg}");
1167
1168                        if e.is_definitive_broadcast_rejection() {
1169                            emit_partitioned_cancel_failure(
1170                                &long_term_orders,
1171                                &emitter,
1172                                clock,
1173                                &CommandFailure::venue_rejected(&msg),
1174                            );
1175                        }
1176                        errors.push(msg);
1177                    }
1178                }
1179            }
1180            Err(e) => {
1181                let msg = format!("Failed to build long-term cancel messages: {e:?}");
1182                log::error!("{msg}");
1183                emit_partitioned_cancel_failure(
1184                    &long_term_orders,
1185                    &emitter,
1186                    clock,
1187                    &CommandFailure::not_sent(&msg),
1188                );
1189                errors.push(msg);
1190            }
1191        }
1192    }
1193
1194    if !errors.is_empty() {
1195        anyhow::bail!("partitioned cancel failed: {}", errors.join("; "));
1196    }
1197
1198    Ok(())
1199}
1200
1201fn emit_partitioned_cancel_failure(
1202    orders: &[DydxCancelOrderRequest],
1203    emitter: &ExecutionEventEmitter,
1204    clock: &AtomicTime,
1205    failure: &CommandFailure,
1206) {
1207    for order in orders {
1208        match failure {
1209            CommandFailure::NotSent(reason) => emitter.emit_order_cancel_denied_event(
1210                order.strategy_id,
1211                order.instrument_id,
1212                order.client_order_id,
1213                order.venue_order_id,
1214                reason,
1215                clock.get_time_ns(),
1216                Some(order.command_id),
1217            ),
1218            CommandFailure::VenueRejected(reason) => emitter.emit_order_cancel_rejected_event(
1219                order.strategy_id,
1220                order.instrument_id,
1221                order.client_order_id,
1222                order.venue_order_id,
1223                reason,
1224                clock.get_time_ns(),
1225                Some(order.command_id),
1226            ),
1227            CommandFailure::Ambiguous(_) => {}
1228        }
1229    }
1230}
1231
1232fn is_definitive_broadcast_rejection(err: &anyhow::Error) -> bool {
1233    err.downcast_ref::<DydxError>()
1234        .is_some_and(DydxError::is_definitive_broadcast_rejection)
1235}
1236
1237#[async_trait(?Send)]
1238impl ExecutionClient for DydxExecutionClient {
1239    fn is_connected(&self) -> bool {
1240        self.core.is_connected()
1241    }
1242
1243    fn client_id(&self) -> ClientId {
1244        self.core.client_id
1245    }
1246
1247    fn account_id(&self) -> AccountId {
1248        self.core.account_id
1249    }
1250
1251    fn venue(&self) -> Venue {
1252        *DYDX_VENUE
1253    }
1254
1255    fn oms_type(&self) -> OmsType {
1256        self.core.oms_type
1257    }
1258
1259    fn get_account(&self) -> Option<AccountAny> {
1260        self.core.cache().account_owned(&self.core.account_id)
1261    }
1262
1263    fn generate_account_state(
1264        &self,
1265        balances: Vec<AccountBalance>,
1266        margins: Vec<MarginBalance>,
1267        reported: bool,
1268        ts_event: UnixNanos,
1269        info: Option<Params>,
1270    ) -> anyhow::Result<()> {
1271        self.emitter
1272            .emit_account_state(balances, margins, reported, ts_event, info);
1273        Ok(())
1274    }
1275
1276    fn start(&mut self) -> anyhow::Result<()> {
1277        if self.core.is_started() {
1278            log::warn!("dYdX execution client already started");
1279            return Ok(());
1280        }
1281
1282        let sender = get_exec_event_sender();
1283        self.emitter.set_sender(sender);
1284        log::info!("Starting dYdX execution client");
1285        self.core.set_started();
1286        Ok(())
1287    }
1288
1289    fn stop(&mut self) -> anyhow::Result<()> {
1290        if self.core.is_stopped() {
1291            log::warn!("dYdX execution client not started");
1292            return Ok(());
1293        }
1294
1295        log::info!("Stopping dYdX execution client");
1296        self.session_tasks.begin_shutdown();
1297        self.begin_pending_shutdown();
1298        self.ws_client.begin_shutdown();
1299        self.core.set_stopped();
1300        self.core.set_disconnected();
1301        Ok(())
1302    }
1303
1304    fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
1305        if !self.is_connected() {
1306            let reason = "Cannot submit order: execution client not connected";
1307            log::error!("{reason}");
1308            anyhow::bail!(reason);
1309        }
1310
1311        let current_block = self.block_time_monitor.current_block_height();
1312        let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
1313
1314        let client_order_id = order.client_order_id();
1315        let instrument_id = order.instrument_id();
1316        let strategy_id = order.strategy_id();
1317
1318        if current_block == 0 {
1319            let reason = "Block height not initialized";
1320            log::warn!("Cannot submit order {client_order_id}: {reason}");
1321            self.emitter.emit_order_denied(&order, reason);
1322            return Ok(());
1323        }
1324
1325        if order.is_closed() {
1326            log::warn!("Cannot submit closed order {client_order_id}");
1327            return Ok(());
1328        }
1329
1330        if order.is_quote_quantity() {
1331            let reason = OrderDeniedReason::unsupported_quote_quantity().to_string();
1332            log::warn!("{reason}");
1333            self.emitter.emit_order_denied(&order, &reason);
1334            return Ok(());
1335        }
1336
1337        // Deny unsupported time-in-force values up front so the strategy gets
1338        // an immediate `OrderDenied` rather than a venue-side `code=48` (FOK
1339        // deprecated) or a silent translation to GTC (DAY).
1340        let unsupported_tif_reason = match order.time_in_force() {
1341            TimeInForce::Fok => Some(
1342                "Fill-or-kill (FOK) orders are deprecated by dYdX v4 (chain rejects with code=48)",
1343            ),
1344            TimeInForce::Day => Some("DAY time-in-force is not supported by dYdX v4"),
1345            _ => None,
1346        };
1347
1348        if let Some(reason) = unsupported_tif_reason {
1349            log::warn!("{reason}");
1350            self.emitter.emit_order_denied(&order, reason);
1351            return Ok(());
1352        }
1353
1354        match order.order_type() {
1355            OrderType::Market
1356            | OrderType::Limit
1357            | OrderType::StopMarket
1358            | OrderType::StopLimit
1359            | OrderType::MarketIfTouched
1360            | OrderType::LimitIfTouched => {}
1361            OrderType::TrailingStopMarket | OrderType::TrailingStopLimit => {
1362                let reason = "Trailing stop orders not supported by dYdX v4 protocol";
1363                log::warn!("{reason}");
1364                self.emitter.emit_order_denied(&order, reason);
1365                return Ok(());
1366            }
1367            order_type => {
1368                let reason = format!("Order type {order_type:?} not supported by dYdX");
1369                log::warn!("{reason}");
1370                self.emitter.emit_order_denied(&order, &reason);
1371                return Ok(());
1372            }
1373        }
1374
1375        let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
1376            Ok(components) => components,
1377            Err(e) => {
1378                log::error!("Failed to get execution components: {e}");
1379                self.emitter.emit_order_denied(&order, &e.to_string());
1380                return Ok(());
1381            }
1382        };
1383
1384        let block_height = self.block_time_monitor.current_block_height() as u32;
1385
1386        let encoded = match self.encoder.encode(client_order_id) {
1387            Ok(enc) => enc,
1388            Err(e) => {
1389                log::error!("Failed to generate client order ID: {e}");
1390                self.emitter.emit_order_denied(&order, &e.to_string());
1391                return Ok(());
1392            }
1393        };
1394
1395        self.emitter.emit_order_submitted(&order);
1396        let client_id_u32 = encoded.client_id;
1397        let client_metadata = encoded.client_metadata;
1398
1399        log::debug!(
1400            "[SUBMIT_ORDER] Nautilus '{}' -> dYdX u32={} meta={:#x} | instrument={} side={:?} qty={} type={:?}",
1401            client_order_id,
1402            client_id_u32,
1403            client_metadata,
1404            instrument_id,
1405            order.order_side(),
1406            order.quantity(),
1407            order.order_type()
1408        );
1409
1410        let expire_time = order.expire_time().map(nanos_to_secs_i64);
1411
1412        let order_flags = match order.order_type() {
1413            OrderType::StopMarket
1414            | OrderType::StopLimit
1415            | OrderType::MarketIfTouched
1416            | OrderType::LimitIfTouched => types::ORDER_FLAG_CONDITIONAL,
1417            OrderType::Market => types::ORDER_FLAG_SHORT_TERM,
1418            OrderType::Limit => {
1419                let lifetime = types::OrderLifetime::from_time_in_force(
1420                    order.time_in_force(),
1421                    expire_time,
1422                    false,
1423                    order_builder.max_short_term_secs(),
1424                );
1425                lifetime.order_flags()
1426            }
1427            _ => types::ORDER_FLAG_LONG_TERM,
1428        };
1429
1430        let ts_submitted = self.clock.get_time_ns();
1431        let trader_id = order.trader_id();
1432        self.register_order_context(
1433            client_id_u32,
1434            OrderContext {
1435                client_order_id,
1436                trader_id,
1437                strategy_id,
1438                instrument_id,
1439                submitted_at: ts_submitted,
1440                order_flags,
1441            },
1442        );
1443
1444        // Register dispatch identity so the WS handler emits proper order
1445        // events (OrderAccepted, OrderFilled, OrderCanceled) instead of reports
1446        self.dispatch_state.order_identities.insert(
1447            client_order_id,
1448            OrderIdentity {
1449                instrument_id,
1450                strategy_id,
1451                order_side: order.order_side(),
1452                order_type: order.order_type(),
1453            },
1454        );
1455
1456        self.spawn_order_task(
1457            "submit_order",
1458            strategy_id,
1459            instrument_id,
1460            client_order_id,
1461            async move {
1462                let (msg, order_type_str) = match order.order_type() {
1463                    OrderType::Market => {
1464                        let msg = order_builder.build_market_order_with_reduce_only(
1465                            instrument_id,
1466                            client_id_u32,
1467                            client_metadata,
1468                            order.order_side(),
1469                            order.quantity(),
1470                            order.is_reduce_only(),
1471                            block_height,
1472                        )?;
1473                        (msg, "market")
1474                    }
1475                    OrderType::Limit => {
1476                        let msg = order_builder.build_limit_order(
1477                            instrument_id,
1478                            client_id_u32,
1479                            client_metadata,
1480                            order.order_side(),
1481                            order
1482                                .price()
1483                                .ok_or_else(|| anyhow::anyhow!("Limit order missing price"))?,
1484                            order.quantity(),
1485                            order.time_in_force(),
1486                            order.is_post_only(),
1487                            order.is_reduce_only(),
1488                            block_height,
1489                            expire_time, // Uses default_short_term_expiry if configured
1490                        )?;
1491                        (msg, "limit")
1492                    }
1493                    // Conditional orders use their own expiration logic (not affected by default_short_term_expiry)
1494                    // They are always stored on-chain with long-term semantics
1495                    OrderType::StopMarket => {
1496                        let trigger_price = order.trigger_price().ok_or_else(|| {
1497                            anyhow::anyhow!("Stop market order missing trigger_price")
1498                        })?;
1499                        let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1500                        let msg = order_builder.build_stop_market_order(
1501                            instrument_id,
1502                            client_id_u32,
1503                            client_metadata,
1504                            order.order_side(),
1505                            trigger_price,
1506                            order.quantity(),
1507                            order.is_reduce_only(),
1508                            cond_expire,
1509                        )?;
1510                        (msg, "stop_market")
1511                    }
1512                    OrderType::StopLimit => {
1513                        let trigger_price = order.trigger_price().ok_or_else(|| {
1514                            anyhow::anyhow!("Stop limit order missing trigger_price")
1515                        })?;
1516                        let limit_price = order.price().ok_or_else(|| {
1517                            anyhow::anyhow!("Stop limit order missing limit price")
1518                        })?;
1519                        let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1520                        let msg = order_builder.build_stop_limit_order(
1521                            instrument_id,
1522                            client_id_u32,
1523                            client_metadata,
1524                            order.order_side(),
1525                            trigger_price,
1526                            limit_price,
1527                            order.quantity(),
1528                            order.time_in_force(),
1529                            order.is_post_only(),
1530                            order.is_reduce_only(),
1531                            cond_expire,
1532                        )?;
1533                        (msg, "stop_limit")
1534                    }
1535                    // dYdX TakeProfitMarket maps to Nautilus MarketIfTouched
1536                    OrderType::MarketIfTouched => {
1537                        let trigger_price = order.trigger_price().ok_or_else(|| {
1538                            anyhow::anyhow!("Take profit market order missing trigger_price")
1539                        })?;
1540                        let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1541                        let msg = order_builder.build_take_profit_market_order(
1542                            instrument_id,
1543                            client_id_u32,
1544                            client_metadata,
1545                            order.order_side(),
1546                            trigger_price,
1547                            order.quantity(),
1548                            order.is_reduce_only(),
1549                            cond_expire,
1550                        )?;
1551                        (msg, "take_profit_market")
1552                    }
1553                    // dYdX TakeProfitLimit maps to Nautilus LimitIfTouched
1554                    OrderType::LimitIfTouched => {
1555                        let trigger_price = order.trigger_price().ok_or_else(|| {
1556                            anyhow::anyhow!("Take profit limit order missing trigger_price")
1557                        })?;
1558                        let limit_price = order.price().ok_or_else(|| {
1559                            anyhow::anyhow!("Take profit limit order missing limit price")
1560                        })?;
1561                        let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1562                        let msg = order_builder.build_take_profit_limit_order(
1563                            instrument_id,
1564                            client_id_u32,
1565                            client_metadata,
1566                            order.order_side(),
1567                            trigger_price,
1568                            limit_price,
1569                            order.quantity(),
1570                            order.time_in_force(),
1571                            order.is_post_only(),
1572                            order.is_reduce_only(),
1573                            cond_expire,
1574                        )?;
1575                        (msg, "take_profit_limit")
1576                    }
1577                    _ => unreachable!("Order type already validated"),
1578                };
1579
1580                // Broadcast: short-term orders use cached sequence (no increment),
1581                // stateful orders use broadcast_with_retry (proper sequence management)
1582                let operation = format!("Submit {order_type_str} order {client_order_id}");
1583
1584                if order_flags == types::ORDER_FLAG_SHORT_TERM {
1585                    broadcaster
1586                        .broadcast_short_term(&tx_manager, vec![msg], &operation)
1587                        .await?;
1588                } else {
1589                    broadcaster
1590                        .broadcast_with_retry(&tx_manager, vec![msg], &operation)
1591                        .await?;
1592                }
1593                log::debug!("Successfully submitted {order_type_str} order: {client_order_id}");
1594
1595                Ok(())
1596            },
1597        );
1598
1599        Ok(())
1600    }
1601
1602    fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1603        let orders = self.core.get_orders_for_list(&cmd.order_list)?;
1604        let order_count = orders.len();
1605
1606        if !self.is_connected() {
1607            let reason = "Cannot submit order list: execution client not connected";
1608            log::error!("{reason}");
1609            anyhow::bail!(reason);
1610        }
1611
1612        // Pre-submission TIF gate: deny FOK and DAY before doing any further
1613        // work, mirroring `submit_order`'s gate. Done up front so the strategy
1614        // sees an immediate `OrderDenied` even when the rest of the pipeline
1615        // (block height, TX manager) is not yet ready.
1616        let unsupported_tif_reason = |order: &OrderAny| match order.time_in_force() {
1617            TimeInForce::Fok => Some(
1618                "Fill-or-kill (FOK) orders are deprecated by dYdX v4 (chain rejects with code=48)",
1619            ),
1620            TimeInForce::Day => Some("DAY time-in-force is not supported by dYdX v4"),
1621            _ => None,
1622        };
1623
1624        if orders
1625            .iter()
1626            .any(|order| unsupported_tif_reason(order).is_some())
1627        {
1628            // Deny the whole list: dYdX has no atomic batch semantics worth
1629            // preserving, and siblings must not be left unresolved.
1630            for order in &orders {
1631                let reason = unsupported_tif_reason(order)
1632                    .unwrap_or("Order list denied: sibling order has unsupported time in force");
1633                self.emitter.emit_order_denied(order, reason);
1634            }
1635            return Ok(());
1636        }
1637
1638        let current_block = self.block_time_monitor.current_block_height();
1639        if current_block == 0 {
1640            let reason = "Block height not initialized";
1641            log::warn!("Cannot submit order list: {reason}");
1642            for order in &orders {
1643                self.emitter.emit_order_denied(order, reason);
1644            }
1645            return Ok(());
1646        }
1647
1648        let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
1649            Ok(components) => components,
1650            Err(e) => {
1651                log::error!("Failed to get execution components for batch: {e}");
1652                for order in &orders {
1653                    self.emitter.emit_order_denied(order, &e.to_string());
1654                }
1655                return Ok(());
1656            }
1657        };
1658
1659        let mut order_params: Vec<LimitOrderParams> = Vec::with_capacity(order_count);
1660        let mut order_info: Vec<(ClientOrderId, InstrumentId, StrategyId)> =
1661            Vec::with_capacity(order_count);
1662
1663        for order in &orders {
1664            if order.order_type() != OrderType::Limit {
1665                log::debug!(
1666                    "Order {} has type {:?}, falling back to individual submission",
1667                    order.client_order_id(),
1668                    order.order_type()
1669                );
1670                let submit_cmd = SubmitOrder::new(
1671                    cmd.trader_id,
1672                    cmd.client_id,
1673                    cmd.strategy_id,
1674                    order.instrument_id(),
1675                    order.client_order_id(),
1676                    order.init_event().clone(),
1677                    cmd.exec_algorithm_id,
1678                    cmd.position_id,
1679                    cmd.params.clone(),
1680                    UUID4::new(),
1681                    cmd.ts_init,
1682                    cmd.correlation_id,
1683                );
1684
1685                if let Err(e) = self.submit_order(submit_cmd) {
1686                    log::error!(
1687                        "Failed to submit order {} from order list: {e}",
1688                        order.client_order_id()
1689                    );
1690                }
1691                continue;
1692            }
1693
1694            if order.is_quote_quantity() {
1695                self.emitter.emit_order_denied(
1696                    order,
1697                    &OrderDeniedReason::unsupported_quote_quantity().to_string(),
1698                );
1699                continue;
1700            }
1701
1702            let Some(price) = order.price() else {
1703                self.emitter
1704                    .emit_order_denied(order, "Limit order missing price");
1705                continue;
1706            };
1707
1708            let encoded = match self.encoder.encode(order.client_order_id()) {
1709                Ok(enc) => enc,
1710                Err(e) => {
1711                    log::error!("Failed to generate client order ID: {e}");
1712                    self.emitter.emit_order_denied(order, &e.to_string());
1713                    continue;
1714                }
1715            };
1716            let client_id_u32 = encoded.client_id;
1717            let client_metadata = encoded.client_metadata;
1718
1719            self.emitter.emit_order_submitted(order);
1720
1721            let expire_time_secs = order.expire_time().map(nanos_to_secs_i64);
1722            let lifetime = types::OrderLifetime::from_time_in_force(
1723                order.time_in_force(),
1724                expire_time_secs,
1725                false,
1726                order_builder.max_short_term_secs(),
1727            );
1728
1729            let ts_submitted = self.clock.get_time_ns();
1730            self.register_order_context(
1731                client_id_u32,
1732                OrderContext {
1733                    client_order_id: order.client_order_id(),
1734                    trader_id: order.trader_id(),
1735                    strategy_id: order.strategy_id(),
1736                    instrument_id: order.instrument_id(),
1737                    submitted_at: ts_submitted,
1738                    order_flags: lifetime.order_flags(),
1739                },
1740            );
1741
1742            self.dispatch_state.order_identities.insert(
1743                order.client_order_id(),
1744                OrderIdentity {
1745                    instrument_id: order.instrument_id(),
1746                    strategy_id: order.strategy_id(),
1747                    order_side: order.order_side(),
1748                    order_type: order.order_type(),
1749                },
1750            );
1751
1752            order_params.push(LimitOrderParams {
1753                instrument_id: order.instrument_id(),
1754                client_order_id: client_id_u32,
1755                client_metadata,
1756                side: order.order_side(),
1757                price,
1758                quantity: order.quantity(),
1759                time_in_force: order.time_in_force(),
1760                post_only: order.is_post_only(),
1761                reduce_only: order.is_reduce_only(),
1762                expire_time_ns: order.expire_time(),
1763            });
1764            order_info.push((
1765                order.client_order_id(),
1766                order.instrument_id(),
1767                order.strategy_id(),
1768            ));
1769        }
1770
1771        if order_params.is_empty() {
1772            return Ok(());
1773        }
1774
1775        // dYdX requires each short-term order in its own transaction
1776        let has_short_term = order_params
1777            .iter()
1778            .any(|params| order_builder.is_short_term_order(params));
1779
1780        let block_height = current_block as u32;
1781        let emitter = self.emitter.clone();
1782        let clock = self.clock;
1783
1784        if has_short_term {
1785            log::debug!(
1786                "Submitting {} short-term limit orders concurrently (sequence not consumed)",
1787                order_params.len()
1788            );
1789
1790            self.spawn_labeled("batch_submit_short_term", async move {
1791                // Build and broadcast all orders concurrently -- no sequence coordination needed.
1792                // Short-term orders use cached sequence (not incremented) via broadcast_short_term.
1793                let mut handles = tokio::task::JoinSet::new();
1794
1795                for (params, (client_order_id, instrument_id, strategy_id)) in
1796                    order_params.into_iter().zip(order_info)
1797                {
1798                    let tx_manager = tx_manager.clone();
1799                    let broadcaster = broadcaster.clone();
1800                    let order_builder = order_builder.clone();
1801                    let emitter = emitter.clone();
1802
1803                    handles.spawn(async move {
1804                        let msg = match order_builder
1805                            .build_limit_order_from_params(&params, block_height)
1806                        {
1807                            Ok(m) => m,
1808                            Err(e) => {
1809                                // Local failure after OrderSubmitted: leave the
1810                                // order for in-flight resolution.
1811                                log::error!(
1812                                    "Failed to build order message for {client_order_id}: {e:?}"
1813                                );
1814                                return;
1815                            }
1816                        };
1817
1818                        // Broadcast with cached sequence (short-term orders don't consume sequences)
1819                        let operation = format!("Submit short-term order {client_order_id}");
1820
1821                        if let Err(e) = broadcaster
1822                            .broadcast_short_term(&tx_manager, vec![msg], &operation)
1823                            .await
1824                        {
1825                            if e.is_definitive_broadcast_rejection() {
1826                                let error_msg = format!("Order submission failed: {e:?}");
1827                                log::warn!("{error_msg}");
1828                                let ts_event = clock.get_time_ns();
1829                                emitter.emit_order_rejected_event(
1830                                    strategy_id,
1831                                    instrument_id,
1832                                    client_order_id,
1833                                    &error_msg,
1834                                    ts_event,
1835                                    false,
1836                                );
1837                            } else {
1838                                log::warn!(
1839                                    "Ambiguous dYdX submit failure for {client_order_id}, awaiting reconciliation: {e:?}"
1840                                );
1841                            }
1842                        }
1843                    });
1844                }
1845
1846                while let Some(result) = handles.join_next().await {
1847                    if let Err(e) = result
1848                        && !e.is_cancelled()
1849                    {
1850                        log::warn!("dYdX short-term order task failed: {e}");
1851                    }
1852                }
1853            });
1854        } else {
1855            log::debug!(
1856                "Batch submitting {} long-term limit orders in single transaction",
1857                order_params.len()
1858            );
1859
1860            self.spawn_labeled("batch_submit_long_term", async move {
1861                let msgs: Result<Vec<_>, _> = order_params
1862                    .iter()
1863                    .map(|params| order_builder.build_limit_order_from_params(params, block_height))
1864                    .collect();
1865
1866                let msgs = match msgs {
1867                    Ok(m) => m,
1868                    Err(e) => {
1869                        // Local failure after OrderSubmitted: leave the orders
1870                        // for in-flight resolution.
1871                        log::error!("Failed to build batch order messages: {e:?}");
1872                        return;
1873                    }
1874                };
1875
1876                let operation = format!("Submit batch of {} limit orders", msgs.len());
1877
1878                if let Err(e) = broadcaster
1879                    .broadcast_with_retry(&tx_manager, msgs, &operation)
1880                    .await
1881                {
1882                    if e.is_definitive_broadcast_rejection() {
1883                        // A CheckTx rejection refuses the whole transaction
1884                        // atomically: a venue result for every order in it.
1885                        let error_msg = format!("Batch order submission failed: {e:?}");
1886                        log::warn!("{error_msg}");
1887                        let ts_event = clock.get_time_ns();
1888
1889                        for (client_order_id, instrument_id, strategy_id) in order_info {
1890                            emitter.emit_order_rejected_event(
1891                                strategy_id,
1892                                instrument_id,
1893                                client_order_id,
1894                                &error_msg,
1895                                ts_event,
1896                                false,
1897                            );
1898                        }
1899                    } else {
1900                        log::warn!(
1901                            "Ambiguous dYdX batch submit failure, awaiting reconciliation: {e:?}"
1902                        );
1903                    }
1904                }
1905            });
1906        }
1907
1908        Ok(())
1909    }
1910
1911    /// dYdX does not support native order modification.
1912    ///
1913    /// Strategies should handle `OrderModifyDenied` by canceling and resubmitting.
1914    fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
1915        let reason = "dYdX does not support order modification. Use cancel and resubmit instead.";
1916        log::warn!("{reason}");
1917
1918        self.send_modify_denied(
1919            cmd.strategy_id,
1920            cmd.instrument_id,
1921            cmd.client_order_id,
1922            cmd.venue_order_id,
1923            reason,
1924            cmd.command_id,
1925        );
1926        Ok(())
1927    }
1928
1929    fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1930        let deny = |reason: &str| {
1931            self.emitter.emit_order_cancel_denied_event(
1932                cmd.strategy_id,
1933                cmd.instrument_id,
1934                cmd.client_order_id,
1935                cmd.venue_order_id,
1936                reason,
1937                self.clock.get_time_ns(),
1938                Some(cmd.command_id),
1939            );
1940        };
1941
1942        if !self.is_connected() {
1943            deny("Cannot cancel order: not connected");
1944            return Ok(());
1945        }
1946
1947        let client_order_id = cmd.client_order_id;
1948        let instrument_id = cmd.instrument_id;
1949        let strategy_id = cmd.strategy_id;
1950        let venue_order_id = cmd.venue_order_id;
1951
1952        let (order_time_in_force, order_expire_time) = {
1953            let cache = self.core.cache();
1954
1955            let order = match cache.order(&client_order_id) {
1956                Some(order) => order,
1957                None => {
1958                    deny("Order not found in cache for cancel");
1959                    return Ok(());
1960                }
1961            };
1962
1963            if order.is_closed() {
1964                log::warn!(
1965                    "CancelOrder command for {} when order already {} (will not send to exchange)",
1966                    client_order_id,
1967                    order.status()
1968                );
1969                deny("Cannot cancel a closed order");
1970                return Ok(());
1971            }
1972
1973            if cache.instrument(&instrument_id).is_none() {
1974                log::error!(
1975                    "Cannot cancel order {client_order_id}: instrument {instrument_id} not found in cache"
1976                );
1977                deny("Instrument not found in cache for cancel");
1978                return Ok(());
1979            }
1980
1981            (
1982                order.time_in_force(),
1983                order.expire_time().map(nanos_to_secs_i64),
1984            )
1985        }; // Cache borrow released here
1986
1987        log::debug!("Cancelling order {client_order_id} for instrument {instrument_id}");
1988
1989        let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
1990            Ok(components) => components,
1991            Err(e) => {
1992                deny(&format!(
1993                    "Failed to get execution components for cancel: {e}"
1994                ));
1995                return Ok(());
1996            }
1997        };
1998
1999        let block_height = self.block_time_monitor.current_block_height() as u32;
2000
2001        let encoded = match self.encoder.get(&client_order_id) {
2002            Some(enc) => enc,
2003            None => {
2004                deny("Client order ID not found in encoder for cancel");
2005                return Ok(());
2006            }
2007        };
2008        let client_id_u32 = encoded.client_id;
2009
2010        log::debug!(
2011            "[CANCEL_ORDER] Nautilus '{client_order_id}' -> dYdX u32={client_id_u32} | instrument={instrument_id}"
2012        );
2013
2014        // Stored flags remain authoritative after the order expires
2015        let order_flags = self.get_order_context(client_id_u32).map_or_else(
2016            || {
2017                log::debug!(
2018                    "Order context not found for {client_order_id}, deriving flags from order"
2019                );
2020                types::OrderLifetime::from_time_in_force(
2021                    order_time_in_force, // Using extracted value
2022                    order_expire_time,   // Using extracted value
2023                    false,
2024                    order_builder.max_short_term_secs(),
2025                )
2026                .order_flags()
2027            },
2028            |ctx| ctx.order_flags,
2029        );
2030
2031        let clock = self.clock;
2032        let emitter = self.emitter.clone();
2033
2034        self.spawn_task("cancel_order", async move {
2035            let cancel_msg = match order_builder.build_cancel_order_with_flags(
2036                instrument_id,
2037                client_id_u32,
2038                order_flags,
2039                block_height,
2040            ) {
2041                Ok(msg) => msg,
2042                Err(e) => {
2043                    emitter.emit_order_cancel_denied_event(
2044                        strategy_id,
2045                        instrument_id,
2046                        client_order_id,
2047                        venue_order_id,
2048                        &format!("Cancel command failed local validation: {e:?}"),
2049                        clock.get_time_ns(),
2050                        Some(cmd.command_id),
2051                    );
2052                    return Ok(());
2053                }
2054            };
2055
2056            // Broadcast cancel: short-term uses cached sequence, stateful uses retry
2057            let cancel_op = format!("Cancel order {client_order_id}");
2058            let result = if order_flags == types::ORDER_FLAG_SHORT_TERM {
2059                broadcaster
2060                    .broadcast_short_term(&tx_manager, vec![cancel_msg], &cancel_op)
2061                    .await
2062            } else {
2063                broadcaster
2064                    .broadcast_with_retry(&tx_manager, vec![cancel_msg], &cancel_op)
2065                    .await
2066            };
2067
2068            match result {
2069                Ok(_) => {
2070                    log::debug!("Successfully cancelled order: {client_order_id}");
2071                }
2072                Err(e) if e.is_definitive_broadcast_rejection() => {
2073                    log::warn!("Failed to cancel order {client_order_id}: {e:?}");
2074
2075                    let ts_event = clock.get_time_ns();
2076                    emitter.emit_order_cancel_rejected_event(
2077                        strategy_id,
2078                        instrument_id,
2079                        client_order_id,
2080                        venue_order_id,
2081                        &format!("Cancel order failed: {e:?}"),
2082                        ts_event,
2083                        Some(cmd.command_id),
2084                    );
2085                }
2086                Err(e) => {
2087                    log::warn!(
2088                        "Ambiguous dYdX cancel failure for {client_order_id}, awaiting reconciliation: {e:?}"
2089                    );
2090                }
2091            }
2092
2093            Ok(())
2094        });
2095
2096        Ok(())
2097    }
2098
2099    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
2100        if !self.is_connected() {
2101            anyhow::bail!("Cannot cancel orders: not connected");
2102        }
2103
2104        let instrument_id = cmd.instrument_id;
2105        let order_side_filter = cmd.order_side;
2106
2107        let order_data: Vec<CancelAllOrderData> = {
2108            let cache = self.core.cache();
2109            let side_filter = order_side_filter;
2110            cache
2111                .orders_open(None, Some(&instrument_id), None, None, side_filter)
2112                .into_iter()
2113                .map(|order| {
2114                    (
2115                        order.strategy_id(),
2116                        order.client_order_id(),
2117                        order.venue_order_id(),
2118                        order.time_in_force(),
2119                        order.expire_time(),
2120                    )
2121                })
2122                .collect()
2123        }; // Cache borrow released here
2124
2125        let short_term_count = order_data
2126            .iter()
2127            .filter(|(_, _, _, tif, _)| matches!(tif, TimeInForce::Ioc | TimeInForce::Fok))
2128            .count();
2129        let long_term_count = order_data.len() - short_term_count;
2130
2131        log::debug!(
2132            "Cancel all orders: total={}, short_term={}, long_term={}, instrument_id={instrument_id}, order_side={order_side_filter:?}",
2133            order_data.len(),
2134            short_term_count,
2135            long_term_count
2136        );
2137
2138        let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
2139            Ok(components) => components,
2140            Err(e) => {
2141                log::error!("Failed to get execution components for cancel_all: {e}");
2142                return Ok(());
2143            }
2144        };
2145
2146        let block_height = self.block_time_monitor.current_block_height() as u32;
2147
2148        let mut orders_to_cancel = Vec::new();
2149
2150        for (strategy_id, client_order_id, venue_order_id, _time_in_force, _expire_time) in
2151            &order_data
2152        {
2153            let Some(encoded) = self.encoder.get(client_order_id) else {
2154                log::warn!("Cannot cancel order {client_order_id}: not found in encoder");
2155                continue;
2156            };
2157            let client_id_u32 = encoded.client_id;
2158
2159            let Some(ctx) = self.get_order_context(client_id_u32) else {
2160                log::debug!(
2161                    "Skipping cancel for {client_order_id}: order context already cleaned up (terminal)"
2162                );
2163                continue;
2164            };
2165            orders_to_cancel.push(DydxCancelOrderRequest {
2166                command_id: cmd.command_id,
2167                instrument_id,
2168                client_id: client_id_u32,
2169                order_flags: ctx.order_flags,
2170                strategy_id: *strategy_id,
2171                client_order_id: *client_order_id,
2172                venue_order_id: *venue_order_id,
2173            });
2174        }
2175
2176        if orders_to_cancel.is_empty() {
2177            return Ok(());
2178        }
2179
2180        log::debug!(
2181            "Cancel all: {} orders (short_term={}, long_term={}), instrument_id={instrument_id}, order_side={order_side_filter:?}",
2182            orders_to_cancel.len(),
2183            orders_to_cancel
2184                .iter()
2185                .filter(|order| order.order_flags == types::ORDER_FLAG_SHORT_TERM)
2186                .count(),
2187            orders_to_cancel
2188                .iter()
2189                .filter(|order| order.order_flags != types::ORDER_FLAG_SHORT_TERM)
2190                .count(),
2191        );
2192
2193        let clock = self.clock;
2194        let emitter = self.emitter.clone();
2195
2196        self.spawn_task("cancel_all_orders", async move {
2197            broadcast_partitioned_cancels(
2198                orders_to_cancel,
2199                block_height,
2200                tx_manager,
2201                broadcaster,
2202                order_builder,
2203                emitter,
2204                clock,
2205            )
2206            .await
2207        });
2208
2209        Ok(())
2210    }
2211
2212    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
2213        if cmd.cancels.is_empty() {
2214            return Ok(());
2215        }
2216
2217        if !self.is_connected() {
2218            for cancel in &cmd.cancels {
2219                self.emitter.emit_order_cancel_denied_event(
2220                    cancel.strategy_id,
2221                    cancel.instrument_id,
2222                    cancel.client_order_id,
2223                    cancel.venue_order_id,
2224                    "Cannot cancel orders: not connected",
2225                    self.clock.get_time_ns(),
2226                    Some(cancel.command_id),
2227                );
2228            }
2229
2230            return Ok(());
2231        }
2232
2233        let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
2234            Ok(components) => components,
2235            Err(e) => {
2236                for cancel in &cmd.cancels {
2237                    self.emitter.emit_order_cancel_denied_event(
2238                        cancel.strategy_id,
2239                        cancel.instrument_id,
2240                        cancel.client_order_id,
2241                        cancel.venue_order_id,
2242                        &format!("Failed to get execution components for batch cancel: {e}"),
2243                        self.clock.get_time_ns(),
2244                        Some(cancel.command_id),
2245                    );
2246                }
2247
2248                return Ok(());
2249            }
2250        };
2251
2252        let mut orders_to_cancel = Vec::with_capacity(cmd.cancels.len());
2253        for cancel in &cmd.cancels {
2254            let client_order_id = cancel.client_order_id;
2255            let encoded = match self.encoder.get(&client_order_id) {
2256                Some(enc) => enc,
2257                None => {
2258                    self.emitter.emit_order_cancel_denied_event(
2259                        cancel.strategy_id,
2260                        cancel.instrument_id,
2261                        client_order_id,
2262                        cancel.venue_order_id,
2263                        "Client order ID not found in encoder for cancel",
2264                        self.clock.get_time_ns(),
2265                        Some(cancel.command_id),
2266                    );
2267                    continue;
2268                }
2269            };
2270            let client_id_u32 = encoded.client_id;
2271
2272            let Some(ctx) = self.get_order_context(client_id_u32) else {
2273                self.emitter.emit_order_cancel_denied_event(
2274                    cancel.strategy_id,
2275                    cancel.instrument_id,
2276                    client_order_id,
2277                    cancel.venue_order_id,
2278                    "Order context not found for cancel",
2279                    self.clock.get_time_ns(),
2280                    Some(cancel.command_id),
2281                );
2282                continue;
2283            };
2284
2285            orders_to_cancel.push(DydxCancelOrderRequest {
2286                command_id: cancel.command_id,
2287                instrument_id: cancel.instrument_id,
2288                client_id: client_id_u32,
2289                order_flags: ctx.order_flags,
2290                strategy_id: cancel.strategy_id,
2291                client_order_id,
2292                venue_order_id: cancel.venue_order_id,
2293            });
2294        }
2295
2296        if orders_to_cancel.is_empty() {
2297            log::warn!("No valid orders to cancel in batch");
2298            return Ok(());
2299        }
2300
2301        let block_height = self.block_time_monitor.current_block_height() as u32;
2302        let clock = self.clock;
2303        let emitter = self.emitter.clone();
2304
2305        log::debug!(
2306            "Batch cancelling {} orders via partitioned strategy",
2307            orders_to_cancel.len(),
2308        );
2309
2310        self.spawn_task("batch_cancel_orders", async move {
2311            broadcast_partitioned_cancels(
2312                orders_to_cancel,
2313                block_height,
2314                tx_manager,
2315                broadcaster,
2316                order_builder,
2317                emitter,
2318                clock,
2319            )
2320            .await
2321        });
2322
2323        Ok(())
2324    }
2325
2326    fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
2327        let http_client = self.http_client.clone();
2328        let wallet_address = self.wallet_address.clone();
2329        let subaccount_number = self.subaccount_number;
2330        let account_id = self.core.account_id;
2331        let emitter = self.emitter.clone();
2332
2333        self.spawn_task("query_account", async move {
2334            let account_state = http_client
2335                .request_account_state(&wallet_address, subaccount_number, account_id)
2336                .await
2337                .context("failed to query account state")?;
2338
2339            emitter.emit_account_state(
2340                account_state.balances.clone(),
2341                account_state.margins.clone(),
2342                account_state.is_reported,
2343                account_state.ts_event,
2344                account_state.info,
2345            );
2346            Ok(())
2347        });
2348
2349        Ok(())
2350    }
2351
2352    fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
2353        log::debug!("Querying order: client_order_id={}", cmd.client_order_id);
2354
2355        let http_client = self.http_client.clone();
2356        let wallet_address = self.wallet_address.clone();
2357        let subaccount_number = self.subaccount_number;
2358        let account_id = self.core.account_id;
2359        let emitter = self.emitter.clone();
2360        let client_order_id = cmd.client_order_id;
2361        let venue_order_id = cmd.venue_order_id;
2362        let instrument_id = cmd.instrument_id;
2363
2364        self.spawn_task("query_order", async move {
2365            let reports = http_client
2366                .request_order_status_reports(
2367                    &wallet_address,
2368                    subaccount_number,
2369                    account_id,
2370                    Some(instrument_id),
2371                )
2372                .await
2373                .context("failed to query order status")?;
2374
2375            let report = reports.into_iter().find(|r| {
2376                if venue_order_id.is_some_and(|vid| r.venue_order_id == vid) {
2377                    return true;
2378                }
2379                r.client_order_id.is_some_and(|cid| cid == client_order_id)
2380            });
2381
2382            if let Some(report) = report {
2383                emitter.send_order_status_report(report);
2384            } else {
2385                log::warn!(
2386                    "No order found for client_order_id={client_order_id}, venue_order_id={venue_order_id:?}"
2387                );
2388            }
2389
2390            Ok(())
2391        });
2392
2393        Ok(())
2394    }
2395
2396    async fn connect(&mut self) -> anyhow::Result<()> {
2397        if self.core.is_connected() && self.session_tasks.is_open() && self.pending_tasks.is_open()
2398        {
2399            log::warn!("dYdX execution client already connected");
2400            return Ok(());
2401        }
2402
2403        log::info!("Connecting to dYdX");
2404
2405        self.prepare_task_groups().await?;
2406        let ws_client = self.ws_client.clone();
2407        let setup_guard =
2408            TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
2409                ws_client.begin_shutdown();
2410            });
2411
2412        log::debug!("Loading instruments from HTTP API");
2413        self.http_client.fetch_and_cache_instruments().await?;
2414        log::debug!(
2415            "Loaded {} instruments from HTTP into shared cache",
2416            self.http_client.cached_instruments_count()
2417        );
2418        self.mark_instruments_initialized();
2419
2420        // Initialize gRPC client (deferred from constructor to avoid blocking)
2421        let grpc_urls = self.config.get_grpc_urls();
2422        let mut grpc_client = DydxGrpcClient::new_with_fallback(&grpc_urls)
2423            .await
2424            .context("failed to construct dYdX gRPC client")?;
2425        log::debug!("gRPC client initialized");
2426
2427        // Fetch the initial height synchronously so orders can be submitted immediately
2428        let initial_height = grpc_client
2429            .latest_block_height()
2430            .await
2431            .context("failed to fetch initial block height")?;
2432        // Use current time as approximation; actual timestamps will come from WebSocket updates
2433        self.block_time_monitor
2434            .record_block(initial_height.0 as u64, jiff::Timestamp::now());
2435        log::debug!("Initial block height: {}", initial_height.0);
2436
2437        *self.grpc_client.write().await = Some(grpc_client.clone());
2438
2439        let private_key =
2440            Self::resolve_private_key(&self.config).context("failed to resolve private key")?;
2441        let tx_manager = Arc::new(
2442            TransactionManager::new(
2443                grpc_client.clone(),
2444                &private_key,
2445                self.wallet_address.clone(),
2446                self.get_chain_id(),
2447            )
2448            .context("failed to create TransactionManager")?,
2449        );
2450
2451        tx_manager
2452            .resolve_authenticators()
2453            .await
2454            .context("failed to resolve authenticators")?;
2455
2456        // Proactively initialize sequence from chain so orders can be submitted
2457        // immediately after connect() without first-transaction latency penalty.
2458        tx_manager
2459            .initialize_sequence()
2460            .await
2461            .context("failed to initialize sequence")?;
2462
2463        self.tx_manager = Some(tx_manager);
2464        self.broadcaster = Some(Arc::new(TxBroadcaster::new(
2465            grpc_client,
2466            self.config.grpc_quota(),
2467        )));
2468        self.order_builder = Some(Arc::new(OrderMessageBuilder::new(
2469            self.http_client.clone(),
2470            self.wallet_address.clone(),
2471            self.subaccount_number,
2472            self.block_time_monitor.clone(),
2473        )));
2474        log::debug!(
2475            "OrderMessageBuilder initialized (block_time_monitor ready: {}, max_short_term: {:.1}s)",
2476            self.block_time_monitor.is_ready(),
2477            SHORT_TERM_ORDER_MAXIMUM_LIFETIME as f64
2478                * self.block_time_monitor.seconds_per_block_or_default()
2479        );
2480
2481        let session_result = async {
2482            self.ws_client.connect().await?;
2483            log::debug!("WebSocket connected");
2484
2485            self.ws_client.subscribe_block_height().await?;
2486            log::debug!("Subscribed to block height updates");
2487
2488            self.ws_client.subscribe_markets().await?;
2489            log::debug!("Subscribed to markets");
2490
2491            log::debug!(
2492                "Using wallet address for queries: {} (subaccount {})",
2493                self.wallet_address,
2494                self.subaccount_number
2495            );
2496            self.ws_client
2497                .subscribe_subaccount(&self.wallet_address, self.subaccount_number)
2498                .await?;
2499            log::debug!(
2500                "Subscribed to subaccount updates: {}/{}",
2501                self.wallet_address,
2502                self.subaccount_number
2503            );
2504
2505            let stream = self.ws_client.stream();
2506            self.spawn_ws_stream_handler(stream)?;
2507
2508            // Fills require a registered account for portfolio updates
2509            self.await_account_registered(30.0).await?;
2510
2511            Ok::<(), anyhow::Error>(())
2512        }
2513        .await;
2514
2515        if let Err(e) = session_result {
2516            if let Err(teardown_error) = self.teardown_partial_connect().await {
2517                return Err(e.context(format!(
2518                    "dYdX execution startup teardown failed: {teardown_error}"
2519                )));
2520            }
2521            return Err(e);
2522        }
2523
2524        self.core.set_connected();
2525        setup_guard.disarm();
2526        log::info!("Connected: client_id={}", self.core.client_id);
2527        Ok(())
2528    }
2529
2530    async fn disconnect(&mut self) -> anyhow::Result<()> {
2531        log::info!("Disconnecting from dYdX");
2532
2533        self.begin_pending_shutdown();
2534        let ws_client = self.ws_client.clone();
2535        let disconnect_guard = TaskGroupGuard::new(&[&self.session_tasks], move || {
2536            ws_client.begin_shutdown();
2537        });
2538
2539        let _ = self
2540            .ws_client
2541            .unsubscribe_subaccount(&self.wallet_address, self.subaccount_number)
2542            .await
2543            .map_err(|e| log::warn!("Failed to unsubscribe from subaccount: {e}"));
2544
2545        let _ = self
2546            .ws_client
2547            .unsubscribe_markets()
2548            .await
2549            .map_err(|e| log::warn!("Failed to unsubscribe from markets: {e}"));
2550
2551        let _ = self
2552            .ws_client
2553            .unsubscribe_block_height()
2554            .await
2555            .map_err(|e| log::warn!("Failed to unsubscribe from block height: {e}"));
2556
2557        let shutdown_result = self.teardown_partial_connect().await;
2558        disconnect_guard.disarm();
2559        shutdown_result?;
2560        log::info!("Disconnected: client_id={}", self.core.client_id);
2561        Ok(())
2562    }
2563
2564    async fn generate_order_status_report(
2565        &self,
2566        cmd: &GenerateOrderStatusReport,
2567    ) -> anyhow::Result<Option<OrderStatusReport>> {
2568        // dYdX Indexer `/v4/orders` caps at `limit` and has no offset cursor, so we
2569        // request the maximum page to maximize the chance of finding a match
2570        // on active subaccounts. Callers looking for older orders should prefer
2571        // `generate_mass_status` or narrow via `instrument_id`.
2572        let market = cmd
2573            .instrument_id
2574            .map(|id| id.symbol.as_str().trim_end_matches("-PERP").to_string());
2575
2576        let response = self
2577            .http_client
2578            .inner
2579            .get_orders(
2580                &self.wallet_address,
2581                self.subaccount_number,
2582                market.as_deref(),
2583                Some(DYDX_INDEXER_REPORT_LIMIT),
2584            )
2585            .await
2586            .context("failed to fetch order from dYdX API")?;
2587
2588        if response.is_empty() {
2589            log::debug!(
2590                "No orders returned for {}/subaccount={} (market_filter={:?})",
2591                self.wallet_address,
2592                self.subaccount_number,
2593                market,
2594            );
2595            return Ok(None);
2596        }
2597
2598        let ts_init = UnixNanos::default();
2599        let scanned_count = response.len();
2600
2601        let report = find_matching_order_report(
2602            &response,
2603            cmd.instrument_id,
2604            cmd.client_order_id,
2605            cmd.venue_order_id,
2606            |clob_pair_id| self.get_instrument_by_clob_pair_id(clob_pair_id),
2607            &self.encoder,
2608            self.core.account_id,
2609            ts_init,
2610        )?;
2611
2612        if report.is_none() {
2613            // The target order was not in the fetched page. Surface the scope so
2614            // callers can tell whether the order is older than the page or the
2615            // filters simply didn't match any returned order.
2616            let page_full = scanned_count == DYDX_INDEXER_REPORT_LIMIT as usize;
2617            log::debug!(
2618                "No order matched filters for {}/subaccount={} \
2619                 (client_order_id={:?}, venue_order_id={:?}, instrument_id={:?}, \
2620                 scanned={scanned_count}, page_full={page_full}, limit={DYDX_INDEXER_REPORT_LIMIT})",
2621                self.wallet_address,
2622                self.subaccount_number,
2623                cmd.client_order_id,
2624                cmd.venue_order_id,
2625                cmd.instrument_id,
2626            );
2627        }
2628
2629        Ok(report)
2630    }
2631
2632    async fn generate_order_status_reports(
2633        &self,
2634        cmd: &GenerateOrderStatusReports,
2635    ) -> anyhow::Result<Vec<OrderStatusReport>> {
2636        let response = self
2637            .http_client
2638            .inner
2639            .get_orders(
2640                &self.wallet_address,
2641                self.subaccount_number,
2642                None, // market filter
2643                Some(DYDX_INDEXER_REPORT_LIMIT),
2644            )
2645            .await
2646            .context("failed to fetch orders from dYdX API")?;
2647
2648        let mut reports = Vec::new();
2649        let ts_init = UnixNanos::default();
2650
2651        for order in response {
2652            let instrument = match self.get_instrument_by_clob_pair_id(order.clob_pair_id) {
2653                Some(inst) => inst,
2654                None => continue,
2655            };
2656
2657            if let Some(filter_id) = cmd.instrument_id
2658                && instrument.id() != filter_id
2659            {
2660                continue;
2661            }
2662
2663            match parse_order_status_report(&order, &instrument, self.core.account_id, ts_init) {
2664                Ok(mut r) => {
2665                    if !order.client_id.is_empty()
2666                        && let Ok(client_id_u32) = order.client_id.parse::<u32>()
2667                    {
2668                        self.encoder.register_known_client_id(client_id_u32);
2669
2670                        if let Some(decoded) = self
2671                            .encoder
2672                            .decode_if_known(client_id_u32, order.client_metadata)
2673                        {
2674                            log::debug!(
2675                                "Decoded order: dYdX client_id={} meta={:#x} -> '{}'",
2676                                client_id_u32,
2677                                order.client_metadata,
2678                                decoded,
2679                            );
2680                            r.client_order_id = Some(decoded);
2681                        }
2682                    }
2683                    reports.push(r);
2684                }
2685                Err(e) => {
2686                    log::warn!("Failed to parse order status report: {e}");
2687                }
2688            }
2689        }
2690
2691        retain_order_status_reports(&mut reports, cmd);
2692
2693        // Drop reports that conflict with the local cache: if we already have
2694        // the order in a terminal status (FILLED/CANCELED/EXPIRED/REJECTED/DENIED),
2695        // replaying an `Accepted` from open-check would error in the ExecEngine.
2696        // The venue may legitimately still consider the order open due to clock
2697        // skew between our inferred fill and the next venue update; skipping
2698        // here keeps the engine quiet while reconciliation eventually catches up.
2699        {
2700            let cache = self.core.cache();
2701            reports.retain(|r| {
2702                let Some(cid) = r.client_order_id else {
2703                    return true;
2704                };
2705
2706                match cache.order(&cid) {
2707                    Some(order) if order.status().is_closed() => {
2708                        log::debug!(
2709                            "Skipping reconciliation report for terminal order {cid} \
2710                             (cache status={:?}, venue status={:?})",
2711                            order.status(),
2712                            r.order_status,
2713                        );
2714                        false
2715                    }
2716                    _ => true,
2717                }
2718            });
2719        }
2720
2721        Ok(reports)
2722    }
2723
2724    async fn generate_fill_reports(
2725        &self,
2726        cmd: GenerateFillReports,
2727    ) -> anyhow::Result<Vec<FillReport>> {
2728        let response = self
2729            .http_client
2730            .inner
2731            .get_fills(
2732                &self.wallet_address,
2733                self.subaccount_number,
2734                None, // market filter
2735                Some(DYDX_INDEXER_REPORT_LIMIT),
2736            )
2737            .await
2738            .context("failed to fetch fills from dYdX API")?;
2739
2740        let mut reports = Vec::new();
2741        let ts_init = UnixNanos::default();
2742
2743        for fill in response.fills {
2744            let instrument = match self.get_instrument_by_market(&fill.market) {
2745                Some(inst) => inst,
2746                None => {
2747                    log::warn!("Unknown market in fill: {}", fill.market);
2748                    continue;
2749                }
2750            };
2751
2752            if let Some(filter_id) = cmd.instrument_id
2753                && instrument.id() != filter_id
2754            {
2755                continue;
2756            }
2757
2758            let report = match parse_fill_report(&fill, &instrument, self.core.account_id, ts_init)
2759            {
2760                Ok(r) => r,
2761                Err(e) => {
2762                    log::warn!("Failed to parse fill report: {e}");
2763                    continue;
2764                }
2765            };
2766
2767            reports.push(report);
2768        }
2769
2770        if let Some(venue_order_id) = cmd.venue_order_id {
2771            reports.retain(|r| r.venue_order_id.as_str() == venue_order_id.as_str());
2772        }
2773
2774        Ok(reports)
2775    }
2776
2777    async fn generate_position_status_reports(
2778        &self,
2779        cmd: &GeneratePositionStatusReports,
2780    ) -> anyhow::Result<Vec<PositionStatusReport>> {
2781        let response = self
2782            .http_client
2783            .inner
2784            .get_subaccount(&self.wallet_address, self.subaccount_number)
2785            .await
2786            .context("failed to fetch subaccount from dYdX API")?;
2787
2788        let mut reports = Vec::new();
2789        let ts_init = UnixNanos::default();
2790
2791        for (market_ticker, perp_position) in &response.subaccount.open_perpetual_positions {
2792            let instrument = match self.get_instrument_by_market(market_ticker) {
2793                Some(inst) => inst,
2794                None => {
2795                    log::warn!("Unknown market in position: {market_ticker}");
2796                    continue;
2797                }
2798            };
2799
2800            if let Some(filter_id) = cmd.instrument_id
2801                && instrument.id() != filter_id
2802            {
2803                continue;
2804            }
2805
2806            let report = match parse_position_status_report(
2807                perp_position,
2808                &instrument,
2809                self.core.account_id,
2810                ts_init,
2811            ) {
2812                Ok(r) => r,
2813                Err(e) => {
2814                    log::warn!("Failed to parse position status report: {e}");
2815                    continue;
2816                }
2817            };
2818
2819            reports.push(report);
2820        }
2821
2822        Ok(reports)
2823    }
2824
2825    async fn generate_mass_status(
2826        &self,
2827        lookback_mins: Option<u64>,
2828    ) -> anyhow::Result<Option<ExecutionMassStatus>> {
2829        let ts_init = self.clock.get_time_ns();
2830
2831        let orders_response = self
2832            .http_client
2833            .inner
2834            .get_orders(
2835                &self.wallet_address,
2836                self.subaccount_number,
2837                None,
2838                Some(DYDX_INDEXER_REPORT_LIMIT),
2839            )
2840            .await
2841            .context("failed to fetch orders for mass status")?;
2842
2843        let subaccount_response = self
2844            .http_client
2845            .inner
2846            .get_subaccount(&self.wallet_address, self.subaccount_number)
2847            .await
2848            .context("failed to fetch subaccount for mass status")?;
2849
2850        let fills_response = self
2851            .http_client
2852            .inner
2853            .get_fills(
2854                &self.wallet_address,
2855                self.subaccount_number,
2856                None,
2857                Some(DYDX_INDEXER_REPORT_LIMIT),
2858            )
2859            .await
2860            .context("failed to fetch fills for mass status")?;
2861
2862        let mut order_reports = Vec::new();
2863        let mut orders_filtered = 0usize;
2864
2865        for order in orders_response {
2866            let instrument = match self.get_instrument_by_clob_pair_id(order.clob_pair_id) {
2867                Some(inst) => inst,
2868                None => {
2869                    orders_filtered += 1;
2870                    continue;
2871                }
2872            };
2873
2874            match parse_order_status_report(&order, &instrument, self.core.account_id, ts_init) {
2875                Ok(mut r) => {
2876                    if !order.client_id.is_empty()
2877                        && let Ok(client_id_u32) = order.client_id.parse::<u32>()
2878                    {
2879                        self.encoder.register_known_client_id(client_id_u32);
2880
2881                        if let Some(decoded) = self
2882                            .encoder
2883                            .decode_if_known(client_id_u32, order.client_metadata)
2884                        {
2885                            log::debug!(
2886                                "Decoded reconciliation order: dYdX client_id={} meta={:#x} -> '{}'",
2887                                client_id_u32,
2888                                order.client_metadata,
2889                                decoded,
2890                            );
2891                            r.client_order_id = Some(decoded);
2892                        }
2893                    }
2894                    order_reports.push(r);
2895                }
2896                Err(e) => {
2897                    log::warn!("Failed to parse order status report: {e}");
2898                    orders_filtered += 1;
2899                }
2900            }
2901        }
2902
2903        let mut position_reports = Vec::new();
2904
2905        for (market_ticker, perp_position) in
2906            &subaccount_response.subaccount.open_perpetual_positions
2907        {
2908            let instrument = match self.get_instrument_by_market(market_ticker) {
2909                Some(inst) => inst,
2910                None => continue,
2911            };
2912
2913            match parse_position_status_report(
2914                perp_position,
2915                &instrument,
2916                self.core.account_id,
2917                ts_init,
2918            ) {
2919                Ok(r) => position_reports.push(r),
2920                Err(e) => {
2921                    log::warn!("Failed to parse position status report: {e}");
2922                }
2923            }
2924        }
2925
2926        let mut fill_reports = Vec::new();
2927        let mut fills_filtered = 0usize;
2928
2929        for fill in fills_response.fills {
2930            let instrument = match self.get_instrument_by_market(&fill.market) {
2931                Some(inst) => inst,
2932                None => {
2933                    fills_filtered += 1;
2934                    continue;
2935                }
2936            };
2937
2938            match parse_fill_report(&fill, &instrument, self.core.account_id, ts_init) {
2939                Ok(r) => fill_reports.push(r),
2940                Err(e) => {
2941                    log::warn!("Failed to parse fill report: {e}");
2942                    fills_filtered += 1;
2943                }
2944            }
2945        }
2946
2947        apply_avg_px_from_fills(&mut order_reports, &fill_reports);
2948
2949        // Drop reports that conflict with the local cache: same rationale as in
2950        // `generate_order_status_reports`. On a cold start the cache is empty so
2951        // this is a no-op; on a hot reconciliation pass it prevents replaying
2952        // `Accepted` events for orders the engine already considers terminal.
2953        {
2954            let cache = self.core.cache();
2955            order_reports.retain(|r| {
2956                let Some(cid) = r.client_order_id else {
2957                    return true;
2958                };
2959
2960                match cache.order(&cid) {
2961                    Some(order) if order.status().is_closed() => {
2962                        log::debug!(
2963                            "Skipping reconciliation report for terminal order {cid} \
2964                             (cache status={:?}, venue status={:?})",
2965                            order.status(),
2966                            r.order_status,
2967                        );
2968                        false
2969                    }
2970                    _ => true,
2971                }
2972            });
2973        }
2974
2975        if let Some(mins) = lookback_mins {
2976            let now_ns = self.clock.get_time_ns();
2977            let cutoff = now_ns.saturating_sub(DurationNanos::try_from_mins(mins)?);
2978
2979            let orders_before = order_reports.len();
2980            order_reports.retain(|r| r.ts_last >= cutoff);
2981            let orders_removed = orders_before - order_reports.len();
2982
2983            let fills_before = fill_reports.len();
2984            fill_reports.retain(|r| r.ts_event >= cutoff);
2985            let fills_removed = fills_before - fill_reports.len();
2986
2987            log::debug!(
2988                "Lookback filter ({}min): orders {}->{} (removed {}), fills {}->{} (removed {}), positions {} (unfiltered)",
2989                mins,
2990                orders_before,
2991                order_reports.len(),
2992                orders_removed,
2993                fills_before,
2994                fill_reports.len(),
2995                fills_removed,
2996                position_reports.len(),
2997            );
2998        } else {
2999            log::debug!(
3000                "Generated mass status: {} orders ({} filtered), {} positions, {} fills ({} filtered)",
3001                order_reports.len(),
3002                orders_filtered,
3003                position_reports.len(),
3004                fill_reports.len(),
3005                fills_filtered,
3006            );
3007        }
3008
3009        let mut mass_status = ExecutionMassStatus::new(
3010            self.core.client_id,
3011            self.core.account_id,
3012            self.core.venue,
3013            ts_init,
3014            None, // report_id will be auto-generated
3015        );
3016
3017        mass_status.add_order_reports(order_reports);
3018        mass_status.add_position_reports(position_reports);
3019        mass_status.add_fill_reports(fill_reports);
3020
3021        Ok(Some(mass_status))
3022    }
3023}
3024
3025type CancelAllOrderData = (
3026    StrategyId,
3027    ClientOrderId,
3028    Option<VenueOrderId>,
3029    TimeInForce,
3030    Option<UnixNanos>,
3031);
3032
3033#[derive(Clone, Copy)]
3034struct DydxCancelOrderRequest {
3035    command_id: UUID4,
3036    instrument_id: InstrumentId,
3037    client_id: u32,
3038    order_flags: u32,
3039    strategy_id: StrategyId,
3040    client_order_id: ClientOrderId,
3041    venue_order_id: Option<VenueOrderId>,
3042}
3043
3044fn apply_avg_px_from_fills(order_reports: &mut [OrderStatusReport], fill_reports: &[FillReport]) {
3045    let mut totals: AHashMap<VenueOrderId, (Decimal, Decimal)> = AHashMap::new();
3046    for fill in fill_reports {
3047        let entry = totals.entry(fill.venue_order_id).or_default();
3048        let qty = fill.last_qty.as_decimal();
3049        entry.0 += fill.last_px.as_decimal() * qty;
3050        entry.1 += qty;
3051    }
3052
3053    for report in order_reports {
3054        if let Some((notional, total_qty)) = totals.get(&report.venue_order_id)
3055            && !total_qty.is_zero()
3056        {
3057            report.avg_px = Some(notional / total_qty);
3058        }
3059    }
3060}
3061
3062struct PendingTaskLabel {
3063    id: u64,
3064    labels: Arc<Mutex<AHashMap<u64, &'static str>>>,
3065}
3066
3067impl Drop for PendingTaskLabel {
3068    fn drop(&mut self) {
3069        self.labels.lock().remove(&self.id);
3070    }
3071}
3072
3073#[allow(clippy::too_many_arguments)]
3074fn find_matching_order_report<F>(
3075    orders: &[crate::http::models::Order],
3076    instrument_filter: Option<InstrumentId>,
3077    client_order_id_filter: Option<ClientOrderId>,
3078    venue_order_id_filter: Option<VenueOrderId>,
3079    lookup_instrument: F,
3080    encoder: &ClientOrderIdEncoder,
3081    account_id: AccountId,
3082    ts_init: UnixNanos,
3083) -> anyhow::Result<Option<OrderStatusReport>>
3084where
3085    F: Fn(u32) -> Option<InstrumentAny>,
3086{
3087    for order in orders {
3088        let instrument = match lookup_instrument(order.clob_pair_id) {
3089            Some(inst) => inst,
3090            None => continue,
3091        };
3092
3093        if let Some(filter_id) = instrument_filter
3094            && instrument.id() != filter_id
3095        {
3096            continue;
3097        }
3098
3099        let mut report = parse_order_status_report(order, &instrument, account_id, ts_init)
3100            .context("failed to parse order status report")?;
3101
3102        if !order.client_id.is_empty()
3103            && let Ok(client_id_u32) = order.client_id.parse::<u32>()
3104        {
3105            encoder.register_known_client_id(client_id_u32);
3106
3107            if let Some(decoded) = encoder.decode_if_known(client_id_u32, order.client_metadata) {
3108                log::debug!(
3109                    "Decoded order: dYdX client_id={} meta={:#x} -> '{}'",
3110                    client_id_u32,
3111                    order.client_metadata,
3112                    decoded,
3113                );
3114                report.client_order_id = Some(decoded);
3115            }
3116        }
3117
3118        if let Some(client_order_id) = client_order_id_filter
3119            && report.client_order_id != Some(client_order_id)
3120        {
3121            continue;
3122        }
3123
3124        if let Some(venue_order_id) = venue_order_id_filter
3125            && report.venue_order_id.as_str() != venue_order_id.as_str()
3126        {
3127            continue;
3128        }
3129
3130        return Ok(Some(report));
3131    }
3132
3133    Ok(None)
3134}
3135
3136#[cfg(test)]
3137mod tests {
3138    use std::{cell::RefCell, rc::Rc};
3139
3140    use axum::{Json, Router, http::Uri, routing::get};
3141    use jiff::Timestamp;
3142    use nautilus_common::{
3143        cache::Cache, clock::VirtualClock, factories::OrderFactory, messages::ExecutionEvent,
3144    };
3145    use nautilus_model::{
3146        enums::OrderSide,
3147        identifiers::{Symbol, TraderId},
3148        instruments::{CryptoPerpetual, InstrumentAny},
3149        orders::{Order as _, OrderAny},
3150        types::{Currency, Price, Quantity},
3151    };
3152    use rstest::rstest;
3153    use rust_decimal_macros::dec;
3154    use serde_json::Value;
3155
3156    use super::*;
3157    use crate::{
3158        common::{
3159            consts::DYDX_CLIENT_ID,
3160            enums::{DydxOrderStatus, DydxOrderType, DydxTimeInForce},
3161        },
3162        http::models::Order,
3163    };
3164
3165    fn test_instrument(symbol: &str, venue: &str) -> InstrumentAny {
3166        let instrument_id = InstrumentId::new(Symbol::new(symbol), Venue::new(venue));
3167        InstrumentAny::CryptoPerpetual(
3168            CryptoPerpetual::builder()
3169                .instrument_id(instrument_id)
3170                .raw_symbol(instrument_id.symbol)
3171                .base_currency(Currency::BTC())
3172                .quote_currency(Currency::USD())
3173                .settlement_currency(Currency::USD())
3174                .is_inverse(false)
3175                .price_precision(2)
3176                .size_precision(3)
3177                .price_increment(Price::new(0.01, 2))
3178                .size_increment(Quantity::new(0.001, 3))
3179                .ts_event(UnixNanos::default())
3180                .ts_init(UnixNanos::default())
3181                .build()
3182                .unwrap(),
3183        )
3184    }
3185
3186    fn test_order(id: &str, clob_pair_id: u32, client_id: &str) -> Order {
3187        Order {
3188            id: id.to_string(),
3189            subaccount_id: "sub-1".to_string(),
3190            client_id: client_id.to_string(),
3191            clob_pair_id,
3192            side: OrderSide::Buy,
3193            size: dec!(1.0),
3194            total_filled: dec!(0),
3195            price: dec!(50000),
3196            status: DydxOrderStatus::Open,
3197            order_type: DydxOrderType::Limit,
3198            time_in_force: DydxTimeInForce::Gtt,
3199            reduce_only: false,
3200            post_only: false,
3201            order_flags: 64,
3202            good_til_block: None,
3203            good_til_block_time: None,
3204            created_at_height: Some(100),
3205            client_metadata: 4,
3206            trigger_price: None,
3207            condition_type: None,
3208            conditional_order_trigger_subticks: None,
3209            execution: None,
3210            updated_at: None,
3211            updated_at_height: None,
3212            ticker: None,
3213            subaccount_number: 0,
3214            order_router_address: None,
3215        }
3216    }
3217
3218    fn test_order_factory() -> OrderFactory {
3219        let clock = Rc::new(RefCell::new(VirtualClock::new()));
3220        OrderFactory::new(
3221            TraderId::from("TRADER-001"),
3222            StrategyId::from("S-001"),
3223            Some(0),
3224            Some(0),
3225            clock,
3226            false,
3227            false,
3228        )
3229    }
3230
3231    fn create_execution_client() -> (
3232        DydxExecutionClient,
3233        Rc<RefCell<Cache>>,
3234        tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3235    ) {
3236        const TEST_PRIVATE_KEY: &str =
3237            "0000000000000000000000000000000000000000000000000000000000000001";
3238
3239        let cache = Rc::new(RefCell::new(Cache::default()));
3240        let core = ExecutionClientCore::new(
3241            TraderId::from("TRADER-001"),
3242            *DYDX_CLIENT_ID,
3243            *DYDX_VENUE,
3244            OmsType::Netting,
3245            AccountId::from("DYDX-001"),
3246            AccountType::Margin,
3247            None,
3248            cache.clone(),
3249        );
3250        core.set_connected();
3251
3252        let config = DydxAdapterConfig {
3253            base_url: "http://127.0.0.1:1".to_string(),
3254            ws_url: "ws://127.0.0.1:1".to_string(),
3255            grpc_url: "http://127.0.0.1:1".to_string(),
3256            grpc_urls: vec!["http://127.0.0.1:1".to_string()],
3257            wallet_address: Some("dydx1test".to_string()),
3258            private_key: Some(TEST_PRIVATE_KEY.into()),
3259            ..Default::default()
3260        };
3261
3262        let mut client =
3263            DydxExecutionClient::new(core, config, "dydx1test".to_string(), 0).unwrap();
3264        client
3265            .block_time_monitor
3266            .record_block(100, Timestamp::now());
3267
3268        let (sender, receiver) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
3269        client.emitter.set_sender(sender);
3270
3271        (client, cache, receiver)
3272    }
3273
3274    #[rstest]
3275    #[tokio::test]
3276    async fn test_mass_status_captures_collection_start() {
3277        let clock: &'static AtomicTime =
3278            Box::leak(Box::new(AtomicTime::new(false, UnixNanos::from(100))));
3279
3280        let router = Router::new().fallback(get(move |uri: Uri| async move {
3281            clock.set_time(UnixNanos::from(200));
3282
3283            let fixture = if uri.path() == "/v4/orders" {
3284                include_str!("../../test_data/http_get_orders.json")
3285            } else if uri.path() == "/v4/fills" {
3286                include_str!("../../test_data/http_get_fills.json")
3287            } else {
3288                include_str!("../../test_data/http_get_subaccount.json")
3289            };
3290
3291            let value: Value = serde_json::from_str(fixture).unwrap();
3292            Json(value["result"].clone())
3293        }));
3294
3295        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
3296        let addr = listener.local_addr().unwrap();
3297
3298        let server = tokio::spawn(async move {
3299            axum::serve(listener, router).await.unwrap();
3300        });
3301
3302        let (mut client, _cache, _rx) = create_execution_client();
3303        client.clock = clock;
3304        client.http_client = DydxHttpClient::new(
3305            Some(format!("http://{addr}")),
3306            5,
3307            None,
3308            client.config.network,
3309            None,
3310        )
3311        .unwrap();
3312
3313        let snapshot = client.generate_mass_status(None).await.unwrap().unwrap();
3314        server.abort();
3315
3316        assert_eq!(snapshot.ts_init, UnixNanos::from(100));
3317        assert_eq!(clock.get_time_ns(), UnixNanos::from(200));
3318    }
3319
3320    fn cache_order(cache: &Rc<RefCell<Cache>>, order: OrderAny) {
3321        cache
3322            .borrow_mut()
3323            .add_order(order, None, Some(*DYDX_CLIENT_ID), false)
3324            .unwrap();
3325    }
3326
3327    fn recv_order_event(
3328        rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3329    ) -> OrderEventAny {
3330        match rx.try_recv().expect("expected execution event") {
3331            ExecutionEvent::Order(event) => event,
3332            event => panic!("Expected order event, was {event:?}"),
3333        }
3334    }
3335
3336    #[rstest]
3337    fn test_submit_order_denies_quote_quantity() {
3338        let (client, cache, mut rx) = create_execution_client();
3339        let mut factory = test_order_factory();
3340        let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3341        let order = factory.market(
3342            instrument_id,
3343            OrderSide::Buy,
3344            Quantity::from("100"),
3345            Some(TimeInForce::Ioc),
3346            None,
3347            Some(true),
3348            None,
3349            None,
3350            None,
3351            Some(ClientOrderId::from("O-QUOTE-QTY")),
3352        );
3353        cache_order(&cache, order.clone());
3354
3355        let command = SubmitOrder::from_order(
3356            &order,
3357            order.trader_id(),
3358            Some(*DYDX_CLIENT_ID),
3359            None,
3360            UUID4::new(),
3361            UnixNanos::default(),
3362        );
3363        client.submit_order(command).unwrap();
3364
3365        match recv_order_event(&mut rx) {
3366            OrderEventAny::Denied(event) => {
3367                assert_eq!(event.client_order_id, order.client_order_id());
3368                assert_eq!(event.instrument_id, instrument_id);
3369                assert_eq!(event.reason, "UNSUPPORTED_QUOTE_QUANTITY");
3370            }
3371            event => panic!("Expected order denied event, was {event:?}"),
3372        }
3373    }
3374
3375    #[rstest]
3376    fn test_submit_order_denies_market_fok() {
3377        let (client, cache, mut rx) = create_execution_client();
3378        let mut factory = test_order_factory();
3379        let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3380        let order = factory.market(
3381            instrument_id,
3382            OrderSide::Buy,
3383            Quantity::from("0.1"),
3384            Some(TimeInForce::Fok),
3385            None,
3386            Some(false),
3387            None,
3388            None,
3389            None,
3390            Some(ClientOrderId::from("O-MARKET-FOK")),
3391        );
3392        cache_order(&cache, order.clone());
3393
3394        let command = SubmitOrder::from_order(
3395            &order,
3396            order.trader_id(),
3397            Some(*DYDX_CLIENT_ID),
3398            None,
3399            UUID4::new(),
3400            UnixNanos::default(),
3401        );
3402        client.submit_order(command).unwrap();
3403
3404        match recv_order_event(&mut rx) {
3405            OrderEventAny::Denied(event) => {
3406                assert_eq!(event.client_order_id, order.client_order_id());
3407                assert_eq!(event.instrument_id, instrument_id);
3408                assert!(
3409                    event.reason.contains("Fill-or-kill") && event.reason.contains("deprecated"),
3410                    "expected FOK-deprecation reason, was: {}",
3411                    event.reason,
3412                );
3413            }
3414            event => panic!("Expected order denied event, was {event:?}"),
3415        }
3416    }
3417
3418    #[rstest]
3419    fn test_submit_order_denies_limit_fok() {
3420        // dYdX v4 deprecated FOK at the protocol level (chain returns code=48).
3421        // The adapter must deny FOK pre-submission so the strategy gets an
3422        // immediate `OrderDenied` instead of a venue-side broadcast failure.
3423        let (client, cache, mut rx) = create_execution_client();
3424        let mut factory = test_order_factory();
3425        let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3426        let order = factory.limit(
3427            instrument_id,
3428            OrderSide::Buy,
3429            Quantity::from("0.1"),
3430            Price::from("50000.0"),
3431            Some(TimeInForce::Fok),
3432            None,
3433            Some(false),
3434            None,
3435            Some(false),
3436            None,
3437            None,
3438            None,
3439            None,
3440            None,
3441            None,
3442            Some(ClientOrderId::from("O-LIMIT-FOK")),
3443        );
3444        cache_order(&cache, order.clone());
3445
3446        let command = SubmitOrder::from_order(
3447            &order,
3448            order.trader_id(),
3449            Some(*DYDX_CLIENT_ID),
3450            None,
3451            UUID4::new(),
3452            UnixNanos::default(),
3453        );
3454        client.submit_order(command).unwrap();
3455
3456        match recv_order_event(&mut rx) {
3457            OrderEventAny::Denied(event) => {
3458                assert_eq!(event.client_order_id, order.client_order_id());
3459                assert!(
3460                    event.reason.contains("Fill-or-kill") && event.reason.contains("deprecated"),
3461                    "expected FOK-deprecation reason, was: {}",
3462                    event.reason,
3463                );
3464            }
3465            event => panic!("Expected order denied event, was {event:?}"),
3466        }
3467    }
3468
3469    #[rstest]
3470    fn test_submit_order_denies_day_tif() {
3471        // DAY TIF is not supported by dYdX v4; the adapter must deny pre-submission
3472        // rather than silently translate to GTC.
3473        let (client, cache, mut rx) = create_execution_client();
3474        let mut factory = test_order_factory();
3475        let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3476        let order = factory.limit(
3477            instrument_id,
3478            OrderSide::Buy,
3479            Quantity::from("0.1"),
3480            Price::from("50000.0"),
3481            Some(TimeInForce::Day),
3482            None,
3483            Some(false),
3484            None,
3485            Some(false),
3486            None,
3487            None,
3488            None,
3489            None,
3490            None,
3491            None,
3492            Some(ClientOrderId::from("O-LIMIT-DAY")),
3493        );
3494        cache_order(&cache, order.clone());
3495
3496        let command = SubmitOrder::from_order(
3497            &order,
3498            order.trader_id(),
3499            Some(*DYDX_CLIENT_ID),
3500            None,
3501            UUID4::new(),
3502            UnixNanos::default(),
3503        );
3504        client.submit_order(command).unwrap();
3505
3506        match recv_order_event(&mut rx) {
3507            OrderEventAny::Denied(event) => {
3508                assert_eq!(event.client_order_id, order.client_order_id());
3509                assert!(
3510                    event.reason.contains("DAY"),
3511                    "expected DAY-unsupported reason, was: {}",
3512                    event.reason,
3513                );
3514            }
3515            event => panic!("Expected order denied event, was {event:?}"),
3516        }
3517    }
3518
3519    #[rstest]
3520    #[tokio::test]
3521    async fn test_submit_order_list_denies_quote_quantity() {
3522        use nautilus_model::{
3523            identifiers::OrderListId,
3524            orders::{OrderList, builder::OrderTestBuilder},
3525        };
3526
3527        let requests = Arc::new(std::sync::atomic::AtomicUsize::new(0));
3528        let observed_requests = Arc::clone(&requests);
3529        let router = Router::new().fallback(move || {
3530            observed_requests.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
3531            async { axum::http::StatusCode::NOT_FOUND }
3532        });
3533
3534        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
3535        let addr = listener.local_addr().unwrap();
3536        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
3537        let grpc = DydxGrpcClient::new(format!("http://{addr}")).await.unwrap();
3538        let (mut client, cache, mut rx) = create_execution_client();
3539        client.tx_manager = Some(Arc::new(
3540            TransactionManager::new(
3541                grpc.clone(),
3542                &DydxExecutionClient::resolve_private_key(&client.config).unwrap(),
3543                client.wallet_address.clone(),
3544                client.get_chain_id(),
3545            )
3546            .unwrap(),
3547        ));
3548        client.broadcaster = Some(Arc::new(TxBroadcaster::new(
3549            grpc,
3550            client.config.grpc_quota(),
3551        )));
3552        client.order_builder = Some(Arc::new(OrderMessageBuilder::new(
3553            client.http_client.clone(),
3554            client.wallet_address.clone(),
3555            client.subaccount_number,
3556            client.block_time_monitor.clone(),
3557        )));
3558        let order = OrderTestBuilder::new(OrderType::Limit)
3559            .instrument_id(InstrumentId::from("BTC-USD-PERP.DYDX"))
3560            .quantity(Quantity::from("100"))
3561            .price(Price::from("50000"))
3562            .quote_quantity(true)
3563            .build();
3564        cache_order(&cache, order.clone());
3565
3566        let order_list = OrderList::new(
3567            OrderListId::from("OL-QUOTE"),
3568            order.instrument_id(),
3569            order.strategy_id(),
3570            vec![order.client_order_id()],
3571            UnixNanos::default(),
3572        );
3573
3574        let command = SubmitOrderList::new(
3575            order.trader_id(),
3576            Some(*DYDX_CLIENT_ID),
3577            order.strategy_id(),
3578            order_list,
3579            vec![order.init_event().clone()],
3580            None,
3581            None,
3582            None,
3583            UUID4::new(),
3584            UnixNanos::default(),
3585            None,
3586        );
3587
3588        client.submit_order_list(command).unwrap();
3589
3590        let OrderEventAny::Denied(denied) = recv_order_event(&mut rx) else {
3591            panic!("Expected order denial");
3592        };
3593
3594        assert_eq!(denied.client_order_id, order.client_order_id());
3595        assert_eq!(denied.instrument_id, order.instrument_id());
3596        assert_eq!(denied.reason.as_str(), "UNSUPPORTED_QUOTE_QUANTITY");
3597        assert_eq!(
3598            rx.try_recv().unwrap_err(),
3599            tokio::sync::mpsc::error::TryRecvError::Empty
3600        );
3601        assert_eq!(requests.load(std::sync::atomic::Ordering::Relaxed), 0);
3602        server.abort();
3603    }
3604
3605    // `submit_order_list` mirrors the single-submit TIF gate; an order in the
3606    // list with FOK or DAY must be denied pre-submission rather than
3607    // forwarded to the gRPC builder.
3608    #[rstest]
3609    #[case(TimeInForce::Fok, "Fill-or-kill")]
3610    #[case(TimeInForce::Day, "DAY")]
3611    fn test_submit_order_list_denies_unsupported_tif(
3612        #[case] tif: TimeInForce,
3613        #[case] reason_substring: &str,
3614    ) {
3615        use nautilus_common::messages::execution::SubmitOrderList;
3616        use nautilus_model::{identifiers::OrderListId, orders::OrderList};
3617
3618        let (client, cache, mut rx) = create_execution_client();
3619        let mut factory = test_order_factory();
3620        let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3621        let order = factory.limit(
3622            instrument_id,
3623            OrderSide::Buy,
3624            Quantity::from("0.1"),
3625            Price::from("50000.0"),
3626            Some(tif),
3627            None,
3628            Some(false),
3629            None,
3630            Some(false),
3631            None,
3632            None,
3633            None,
3634            None,
3635            None,
3636            None,
3637            Some(ClientOrderId::from("O-LIST-1")),
3638        );
3639        cache_order(&cache, order.clone());
3640
3641        let order_list = OrderList::new(
3642            OrderListId::from("OL-1"),
3643            instrument_id,
3644            order.strategy_id(),
3645            vec![order.client_order_id()],
3646            UnixNanos::default(),
3647        );
3648        let init = order.init_event().clone();
3649
3650        let cmd = SubmitOrderList::new(
3651            order.trader_id(),
3652            Some(*DYDX_CLIENT_ID),
3653            order.strategy_id(),
3654            order_list,
3655            vec![init],
3656            None,
3657            None,
3658            None,
3659            UUID4::new(),
3660            UnixNanos::default(),
3661            None, // correlation_id
3662        );
3663        client.submit_order_list(cmd).unwrap();
3664
3665        match recv_order_event(&mut rx) {
3666            OrderEventAny::Denied(event) => {
3667                assert_eq!(event.client_order_id, order.client_order_id());
3668                assert!(
3669                    event.reason.contains(reason_substring),
3670                    "expected reason containing {reason_substring:?}, was: {}",
3671                    event.reason,
3672                );
3673            }
3674            event => panic!("Expected order denied event, was {event:?}"),
3675        }
3676    }
3677
3678    // A mixed list must not leave supported sibling orders unresolved: when
3679    // the list is aborted for an unsupported TIF, every order is denied.
3680    #[rstest]
3681    fn test_submit_order_list_denies_supported_siblings_on_abort() {
3682        use nautilus_common::messages::execution::SubmitOrderList;
3683        use nautilus_model::{identifiers::OrderListId, orders::OrderList};
3684
3685        let (client, cache, mut rx) = create_execution_client();
3686        let mut factory = test_order_factory();
3687        let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3688        let order_gtc = factory.limit(
3689            instrument_id,
3690            OrderSide::Buy,
3691            Quantity::from("0.1"),
3692            Price::from("50000.0"),
3693            Some(TimeInForce::Gtc),
3694            None,
3695            Some(false),
3696            None,
3697            Some(false),
3698            None,
3699            None,
3700            None,
3701            None,
3702            None,
3703            None,
3704            Some(ClientOrderId::from("O-MIXED-GTC")),
3705        );
3706        let order_fok = factory.limit(
3707            instrument_id,
3708            OrderSide::Sell,
3709            Quantity::from("0.1"),
3710            Price::from("51000.0"),
3711            Some(TimeInForce::Fok),
3712            None,
3713            Some(false),
3714            None,
3715            Some(false),
3716            None,
3717            None,
3718            None,
3719            None,
3720            None,
3721            None,
3722            Some(ClientOrderId::from("O-MIXED-FOK")),
3723        );
3724        cache_order(&cache, order_gtc.clone());
3725        cache_order(&cache, order_fok.clone());
3726
3727        let order_list = OrderList::new(
3728            OrderListId::from("OL-MIXED"),
3729            instrument_id,
3730            order_gtc.strategy_id(),
3731            vec![order_gtc.client_order_id(), order_fok.client_order_id()],
3732            UnixNanos::default(),
3733        );
3734
3735        let cmd = SubmitOrderList::new(
3736            order_gtc.trader_id(),
3737            Some(*DYDX_CLIENT_ID),
3738            order_gtc.strategy_id(),
3739            order_list,
3740            vec![
3741                order_gtc.init_event().clone(),
3742                order_fok.init_event().clone(),
3743            ],
3744            None,
3745            None,
3746            None,
3747            UUID4::new(),
3748            UnixNanos::default(),
3749            None, // correlation_id
3750        );
3751        client.submit_order_list(cmd).unwrap();
3752
3753        let mut denied_reasons = std::collections::HashMap::new();
3754
3755        for _ in 0..2 {
3756            match recv_order_event(&mut rx) {
3757                OrderEventAny::Denied(event) => {
3758                    denied_reasons.insert(event.client_order_id, event.reason);
3759                }
3760                event => panic!("Expected order denied event, was {event:?}"),
3761            }
3762        }
3763
3764        assert!(
3765            denied_reasons[&order_gtc.client_order_id()].contains("sibling order"),
3766            "GTC sibling should be denied with list-abort reason",
3767        );
3768        assert!(
3769            denied_reasons[&order_fok.client_order_id()].contains("Fill-or-kill"),
3770            "FOK order should be denied with TIF reason",
3771        );
3772    }
3773
3774    // Shutdown should retain cancel-related labels until the registered task
3775    // completes or its join is observed after forced abort.
3776    #[tokio::test]
3777    async fn test_pending_task_labels_drain_with_scope() {
3778        let (client, _cache, _rx) = create_execution_client();
3779
3780        client.spawn_labeled("cancel_all_orders", async {
3781            tokio::time::sleep(std::time::Duration::from_secs(60)).await;
3782        });
3783        client.spawn_labeled("submit_order", async {
3784            tokio::time::sleep(std::time::Duration::from_secs(60)).await;
3785        });
3786
3787        {
3788            let labels = client.pending_task_labels.lock();
3789            assert_eq!(labels.len(), 2);
3790        }
3791
3792        client.begin_pending_shutdown();
3793        client
3794            .pending_tasks
3795            .finish_shutdown(Duration::ZERO, Duration::from_secs(1))
3796            .await
3797            .unwrap();
3798
3799        assert!(client.pending_tasks.is_empty());
3800        assert!(client.pending_task_labels.lock().is_empty());
3801    }
3802
3803    // The label substring used by `begin_pending_shutdown` to recognize cancel
3804    // tasks must match the labels actually used at spawn sites. Pin those
3805    // sites here so a rename in only one place is caught.
3806    #[rstest]
3807    #[case("cancel_all_orders", true)]
3808    #[case("batch_cancel_orders", true)]
3809    #[case("Submit order", false)]
3810    #[case("batch_submit_short_term", false)]
3811    #[case("batch_submit_long_term", false)]
3812    fn test_pending_task_label_classification(
3813        #[case] label: &'static str,
3814        #[case] is_cancel: bool,
3815    ) {
3816        // The classification branch is `label.contains("cancel")` (lowercase).
3817        // This test locks the substring so an accidental rename of a labeled
3818        // spawn site breaks the assertion at compile time.
3819        assert_eq!(label.contains("cancel"), is_cancel);
3820    }
3821
3822    #[rstest]
3823    #[case(false)]
3824    #[case(true)]
3825    fn test_emit_partitioned_cancel_failure_emits_each_cancel(#[case] not_sent: bool) {
3826        let clock = get_atomic_clock_realtime();
3827        let mut emitter = ExecutionEventEmitter::new(
3828            clock,
3829            TraderId::from("TRADER-001"),
3830            AccountId::from("DYDX-001"),
3831            AccountType::Margin,
3832            None,
3833        );
3834        let (sender, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
3835        emitter.set_sender(sender);
3836
3837        let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3838        let orders = vec![
3839            DydxCancelOrderRequest {
3840                command_id: UUID4::new(),
3841                instrument_id,
3842                client_id: 1,
3843                order_flags: types::ORDER_FLAG_SHORT_TERM,
3844                strategy_id: StrategyId::from("S-001"),
3845                client_order_id: ClientOrderId::from("O-CANCEL-1"),
3846                venue_order_id: Some(VenueOrderId::from("V-1")),
3847            },
3848            DydxCancelOrderRequest {
3849                command_id: UUID4::new(),
3850                instrument_id,
3851                client_id: 2,
3852                order_flags: types::ORDER_FLAG_LONG_TERM,
3853                strategy_id: StrategyId::from("S-001"),
3854                client_order_id: ClientOrderId::from("O-CANCEL-2"),
3855                venue_order_id: Some(VenueOrderId::from("V-2")),
3856            },
3857        ];
3858
3859        let failure = if not_sent {
3860            CommandFailure::not_sent("broadcast failed")
3861        } else {
3862            CommandFailure::venue_rejected("broadcast failed")
3863        };
3864
3865        emit_partitioned_cancel_failure(&orders, &emitter, clock, &failure);
3866
3867        for order in &orders {
3868            match recv_order_event(&mut rx) {
3869                OrderEventAny::CancelDenied(event) if not_sent => {
3870                    assert_eq!(event.client_order_id, order.client_order_id);
3871                    assert_eq!(event.instrument_id, order.instrument_id);
3872                    assert_eq!(event.venue_order_id, order.venue_order_id);
3873                    assert_eq!(event.reason, "broadcast failed");
3874                    assert_eq!(event.causation_id, Some(order.command_id));
3875                }
3876                OrderEventAny::CancelRejected(event) if !not_sent => {
3877                    assert_eq!(event.causation_id, Some(order.command_id));
3878                    assert_eq!(event.client_order_id, order.client_order_id);
3879                    assert_eq!(event.instrument_id, order.instrument_id);
3880                    assert_eq!(event.venue_order_id, order.venue_order_id);
3881                    assert_eq!(event.reason, "broadcast failed");
3882                }
3883                event => panic!("Expected order cancel rejected event, was {event:?}"),
3884            }
3885        }
3886        assert!(rx.try_recv().is_err());
3887    }
3888
3889    #[rstest]
3890    fn test_find_matching_order_report_returns_later_match() {
3891        // Regression guard: earlier implementation fetched limit=1 and returned None
3892        // when the first order didn't match the filter. The fixed iteration logic must
3893        // scan the whole response and return the matching entry.
3894        let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3895        let eth_inst = test_instrument("ETH-USD-PERP", "DYDX");
3896
3897        let orders = vec![
3898            test_order("order-eth", 1, "22222"),
3899            test_order("order-btc", 0, "11111"),
3900        ];
3901
3902        let encoder = ClientOrderIdEncoder::new();
3903        let report = find_matching_order_report(
3904            &orders,
3905            Some(btc_inst.id()),
3906            None,
3907            None,
3908            |clob_pair_id| match clob_pair_id {
3909                0 => Some(btc_inst.clone()),
3910                1 => Some(eth_inst.clone()),
3911                _ => None,
3912            },
3913            &encoder,
3914            AccountId::new("DYDX-001"),
3915            UnixNanos::default(),
3916        )
3917        .expect("lookup should succeed");
3918
3919        let report = report.expect("matching order should be found");
3920        assert_eq!(report.instrument_id, btc_inst.id());
3921        assert_eq!(report.venue_order_id.as_str(), "order-btc");
3922    }
3923
3924    #[rstest]
3925    fn test_find_matching_order_report_returns_none_when_no_match() {
3926        let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3927        let eth_inst = test_instrument("ETH-USD-PERP", "DYDX");
3928
3929        let orders = vec![
3930            test_order("order-eth-1", 1, "22222"),
3931            test_order("order-eth-2", 1, "33333"),
3932        ];
3933
3934        let encoder = ClientOrderIdEncoder::new();
3935        let report = find_matching_order_report(
3936            &orders,
3937            Some(btc_inst.id()),
3938            None,
3939            None,
3940            |clob_pair_id| match clob_pair_id {
3941                0 => Some(btc_inst.clone()),
3942                1 => Some(eth_inst.clone()),
3943                _ => None,
3944            },
3945            &encoder,
3946            AccountId::new("DYDX-001"),
3947            UnixNanos::default(),
3948        )
3949        .expect("lookup should succeed");
3950
3951        assert!(report.is_none());
3952    }
3953
3954    #[rstest]
3955    fn test_find_matching_order_report_filters_by_venue_order_id() {
3956        let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3957
3958        let orders = vec![
3959            test_order("order-a", 0, "11111"),
3960            test_order("order-b", 0, "22222"),
3961            test_order("order-c", 0, "33333"),
3962        ];
3963
3964        let encoder = ClientOrderIdEncoder::new();
3965        let target = VenueOrderId::new("order-b");
3966        let report = find_matching_order_report(
3967            &orders,
3968            None,
3969            None,
3970            Some(target),
3971            |_| Some(btc_inst.clone()),
3972            &encoder,
3973            AccountId::new("DYDX-001"),
3974            UnixNanos::default(),
3975        )
3976        .expect("lookup should succeed")
3977        .expect("matching order should be found");
3978
3979        assert_eq!(report.venue_order_id.as_str(), "order-b");
3980    }
3981
3982    #[rstest]
3983    fn test_find_matching_order_report_skips_orders_without_cached_instrument() {
3984        let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3985
3986        let orders = vec![
3987            test_order("order-unknown", 99, "11111"),
3988            test_order("order-btc", 0, "22222"),
3989        ];
3990
3991        let encoder = ClientOrderIdEncoder::new();
3992        let report = find_matching_order_report(
3993            &orders,
3994            Some(btc_inst.id()),
3995            None,
3996            None,
3997            |clob_pair_id| (clob_pair_id == 0).then(|| btc_inst.clone()),
3998            &encoder,
3999            AccountId::new("DYDX-001"),
4000            UnixNanos::default(),
4001        )
4002        .expect("lookup should succeed")
4003        .expect("matching order should be found");
4004
4005        assert_eq!(report.venue_order_id.as_str(), "order-btc");
4006    }
4007}